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);
}
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);
}
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!"
});
}
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!"
});
}
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);
}
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);
}
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);
}
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);
}
[CanBeNull] public ICSharpStatement GetContainingStatement()
{
var expression = PostfixContext.GetOuterExpression(Expression);
var statement = ExpressionStatementNavigator.GetByExpression(expression);
if (statement != null)
{
return(statement);
}
return(RazorUtil.CanBeStatement(expression));
}
public async Task <ActionResult> GetPrevisaoTempo(string estadoEscolhido, string municipioEscolhido)
{
PrevisaoTempoAtualService service = new PrevisaoTempoAtualService();
string parametros = service.MontarParametros(estadoEscolhido, municipioEscolhido);
var retorno = await ApiHelper.GetPrevisaoTempoAtual(parametros);
if (retorno.Sucesso)
{
string painel = RazorUtil.GetTemplate(retorno.Resultado);
return(Json(new { OK = retorno.Sucesso, stringHtml = painel }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { OK = false, Mensagem = retorno.Mensagem, }, JsonRequestBehavior.AllowGet));
}
}
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);
}
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);
}
}
protected override ITreeNode ExpandPostfix(PostfixExpressionContext context)
{
var csharpContext = (CSharpPostfixExpressionContext)context;
var psiModule = csharpContext.PostfixContext.PsiModule;
var psiServices = psiModule.GetPsiServices();
var factory = CSharpElementFactory.GetInstance(psiModule);
var targetStatement = csharpContext.GetContainingStatement();
var expressionRange = csharpContext.Expression.GetDocumentRange();
// Razor issue - hard to convert expression to statement
if (!targetStatement.GetDocumentRange().IsValid())
{
var newStatement = psiServices.DoTransaction(ExpandCommandName, () =>
{
// todo: pass original context?
var expression = csharpContext.Expression.GetOperandThroughParenthesis().NotNull();
return(CreateStatement(factory, expression));
});
var razorStatement = RazorUtil.FixExpressionToStatement(expressionRange, psiServices);
if (razorStatement != null)
{
return(psiServices.DoTransaction(ExpandCommandName, () =>
{
var statement = razorStatement.ReplaceBy(newStatement);
// force Razor's bracing style
var languageService = statement.Language.LanguageService().NotNull();
var formatter = languageService.CodeFormatter.NotNull();
formatter.Format(statement, CodeFormatProfile.SOFT, NullProgressIndicator.Instance);
return statement;
}));
}
Logger.Fail("Failed to resolve target statement to replace");
return(null);
}
return(psiServices.DoTransaction(ExpandCommandName, () =>
{
var expression = csharpContext.Expression.GetOperandThroughParenthesis().NotNull();
var newStatement = CreateStatement(factory, expression);
Assertion.AssertNotNull(targetStatement, "targetStatement != null");
Assertion.Assert(targetStatement.IsPhysical(), "targetStatement.IsPhysical()");
// Sometimes statements produced by templates are unfinished (for example, because of
// parentheses insertion mode in R#), so the created statements has error element at and,
// prefixed with single-characted whitespace. We remove this whitespace here:
var errorElement = newStatement.LastChild as IErrorElement;
if (errorElement != null)
{
var whitespaceNode = errorElement.PrevSibling as IWhitespaceNode;
if (whitespaceNode != null && !whitespaceNode.IsNewLine && whitespaceNode.GetText() == " ")
{
using (WriteLockCookie.Create(newStatement.IsPhysical()))
{
LowLevelModificationUtil.DeleteChild(whitespaceNode);
}
}
}
return targetStatement.ReplaceBy(newStatement);
}));
}
