public async Task <JsonResult> ObterRecursos(int id)
{
try
{
ProjectNode noh = await db.ProjectNodes
.Include(x => x.UsuariosDesteNode)
.Where(x => x.Id == id)
.SingleOrDefaultAsync();
return(Json(new
{
Sucesso = true,
Mensagem = "",
Selecionados = noh.UsuariosDesteNode.Select(x => x.Id).ToList <int>().ToArray()
}, JsonRequestBehavior.AllowGet));
}
catch (Exception err)
{
LogServices.LogarException(err);
return(Json(new
{
Sucesso = false,
Mensagem = err.Message,
Selecionados = new int[] { }
}, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// adiciona os campos de log de auditoria no registro sendo salvo
/// conforme entrada de blog https://benjii.me/2014/03/track-created-and-modified-fields-automatically-with-entity-framework-code-first/
/// </summary>
private void AddTimestamps()
{
try
{
var entries = ChangeTracker.Entries().Where(x => x.Entity is TPAEntity && (x.State == EntityState.Added || x.State == EntityState.Modified));
var currentUsername = !string.IsNullOrEmpty(System.Web.HttpContext.Current?.User?.Identity?.Name)
? HttpContext.Current.User.Identity.Name
: "Anonymous";
foreach (var entry in entries)
{
if (entry.State == EntityState.Added)
{
((TPAEntity)entry.Entity).MomentoInclusao = DateTime.Now;
((TPAEntity)entry.Entity).UsuarioInclusao = currentUsername;
}
((TPAEntity)entry.Entity).MomentoEdicao = DateTime.Now;
((TPAEntity)entry.Entity).UsuarioEdicao = currentUsername;
}
}
catch (Exception auditEx)
{
LogServices.LogarException(auditEx);
}
}
/// <summary>
/// copia para a ExcelWorksheet os dados de GetRelatorio_Analitico
/// </summary>
/// <param name="dtIni">DateTime - data inicial</param>
/// <param name="dtFin">DateTime - data final</param>
/// <param name="ws">ExcelWorksheet - worksheet do pacote epplus para onde vão os dados</param>
private void ConstroiRelatorio_Analitico(DateTime dtIni, DateTime dtFin, ExcelWorksheet ws)
{
var dados = this.GetRelatorio_Analitico(dtIni, dtFin);
int linha = 6;
foreach (var d in dados)
{
try
{
ws.Cells[linha, 1].Value = d.Inicio.Date;
ws.Cells[linha, 2].Value = d.Funcionario;
ws.Cells[linha, 3].Value = d.Tipo_Atividade;
ws.Cells[linha, 4].Value = d.Observacao;
ws.Cells[linha, 5].Value = d.Inicio;
ws.Cells[linha, 6].Value = d.Fim;
ws.Cells[linha, 7].Value = d.Horas;
ws.Cells[linha, 8].Value = d.Administrativo;
ws.Cells[linha, 9].Value = d.Cliente_Raiz;
ws.Cells[linha, 10].Value = d.Cliente;
ws.Cells[linha, 11].Value = d.Area;
ws.Cells[linha, 12].Value = d.Projeto;
ws.Cells[linha, 13].Value = d.Entregaveis;
ws.Cells[linha, 14].Value = d.Etapas;
linha++;
}
catch (Exception err)
{
LogServices.LogarException(err);
}
}
}
/// <summary>
/// sobrecarrega AuthorizeCore e diz se o usuário pode acessar ou não
/// </summary>
/// <param name="httpContext">HttpContextBase - contexto da chamada</param>
/// <returns>bool - true se o usuário estiver autorizado</returns>
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
if ((httpContext.Handler != null) && (httpContext.Handler is MvcHandler))
{
bool podeAcessar = false;
using (TPAContext db = new TPAContext())
{
ControleAcesso c = new ControleAcesso(db);
try
{
var routeData = ((MvcHandler)httpContext.Handler).RequestContext.RouteData;
string actionName = routeData.Values["action"].ToString();
string controllerName = routeData.Values["controller"].ToString();
podeAcessar = c.PodeAcessar(controllerName, actionName);
}
catch (Exception err)
{
LogServices.LogarException(err);
}
}
return(podeAcessar);
}
else
{
return(base.AuthorizeCore(httpContext));
}
}
public async Task <ActionResult> LancaPlanilhaPost(ImportacaoPlanilhaAtividadesViewModel planmodel)
{
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
if (ModelState.IsValid && planmodel != null && planmodel.Itens.Count > 0)
{
try
{
ImportaPlanilhaApplication app = new ImportaPlanilhaApplication(this.db);
int linhas = await app.LancarAsync(planmodel);
MensagemParaUsuarioViewModel.MensagemSucesso(string.Format("Planilha importada com sucesso! {0} linhas da planilha importadas.", linhas), TempData);
return(View("Index"));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
LogServices.LogarException(err);
}
}
return(View(planmodel));
}
/// <summary>
/// copia para a ExcelWorksheet os dados de GetRelatorio_Consolidado_Projeto_Funcionario_Dia
/// </summary>
/// <param name="dtIni">DateTime - data inicial</param>
/// <param name="dtFin">DateTime - data final</param>
/// <param name="ws">ExcelWorksheet - worksheet do pacote epplus para onde vão os dados</param>
private void ConstroiRelatorio_Consolidado_Projeto_Funcionario_Dia(DateTime dtIni, DateTime dtFin, ExcelWorksheet ws)
{
var dados = this.GetRelatorio_Consolidado_Projeto_Funcionario_Dia(dtIni, dtFin);
int linha = 6;
ws.Column(1).Style.Numberformat.Format = "dd/MM/yyyy";
ws.Column(6).Style.Numberformat.Format = "[hh]:mm";
foreach (var d in dados)
{
try
{
ws.Cells[linha, 1].Value = d.Dia;
ws.Cells[linha, 2].Value = d.Funcionario;
ws.Cells[linha, 3].Value = d.Cliente;
ws.Cells[linha, 4].Value = d.Area;
ws.Cells[linha, 5].Value = d.Projeto;
ws.Cells[linha, 6].Value = d.HorasTimeSpan;
linha++;
}
catch (Exception err)
{
LogServices.LogarException(err);
}
}
}
public async Task <ActionResult> Delete(int id)
{
MensagemParaUsuarioViewModel result = new MensagemParaUsuarioViewModel();
ProjectNode prj = await db.ProjectNodes.FindAsync(id);
if (prj != null)
{
try
{
if (prj.Filhos != null && prj.Filhos.Count > 0)
{
result.Sucesso = false;
result.Mensagem = "Não se pode excluir um nó de projeto com dependentes. Exclua os itens primeiro.";
result.Titulo = "Erro ao excluir nó de projeto";
}
else if (prj.Atividades != null && prj.Atividades.Count > 0)
{
result.Sucesso = false;
result.Mensagem = "Este nó de projeto não pode ser excluído porque tem atividades lançadas para ele.";
result.Titulo = "Erro ao excluir nó de projeto";
}
else
{
prj.UsuariosDesteNode.Clear();
db.ProjectNodes.Remove(prj);
await db.SaveChangesAsync();
result.Sucesso = true;
result.Mensagem = "Item excluído com sucesso.";
result.Titulo = "exclusão de item do projeto";
}
}
catch (Exception err)
{
LogServices.LogarException(err);
result.Sucesso = false;
result.Mensagem = err.Message;
if (err.InnerException != null)
{
result.Mensagem += "\r\n" + err.InnerException.Message;
if (err.InnerException.InnerException != null)
{
result.Mensagem += "\r\n" + err.InnerException.InnerException.Message;
}
}
result.Titulo = "Erro ao excluir nó de projeto";
}
}
else
{
result.Sucesso = false;
result.Mensagem = "Não foi selecionado nenhum nó de projeto para exclusão.";
result.Titulo = "Erro ao excluir nó de projeto";
}
return(Json(result));
}
/// <summary>
/// intercepta todos os eventos de salvar assíncronos.
/// validações genéricas devem ser todos aqui
/// logs genéricos devem ser todos aqui
/// restrições de segurança genéricos (baseados em database) devem ser todos aqui
/// </summary>
/// <returns></returns>
public override async Task <int> SaveChangesAsync()
{
try
{
AddTimestamps();
return(await base.SaveChangesAsync());
}
catch (Exception err)
{
LogServices.LogarException(err);
throw;
}
}
/// <summary>
/// não deveria ser usado esse método caso você esteja tentando usar custom errors ou http errors, porque sempre vai cair aqui
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Application_Error(object sender, EventArgs e)
{
Exception err = Server.GetLastError();
if (err != null)
{
LogServices.LogarException(err);
if ((HttpContext.Current != null) && (HttpContext.Current.Session != null))
{
HttpContext.Current.Session.Add("UltimoErro", err);
}
}
}
/// <summary>
/// intercepta todos os eventos de salvar.
/// validações genéricas devem ser todos aqui
/// logs genéricos devem ser todos aqui
/// restrições de segurança genéricos (baseados em database) devem ser todos aqui
/// </summary>
/// <returns></returns>
public override int SaveChanges()
{
try
{
AddTimestamps();
return(base.SaveChanges());
}
catch (Exception err)
{
LogServices.LogarException(err);
throw;
}
}
/// <summary>
/// Evia o alerta de lançamento em atraso para todos os usuários
/// </summary>
/// <param name="email">boolean - se vai receber por e-mail ou não</param>
/// <param name="sms">boolean - se vai receber por sms ou não</param>
/// <param name="telegram">boolean - se vai receber por telegram ou não</param>
/// <returns></returns>
public virtual void EnviarTodosOsAlertas(bool email = true, bool sms = false)
{
var modelo = this.GetUsuariosComAtrasoNoEnvio();
if ((modelo == null) || (modelo.Count == 0))
{
throw new Exception("O usuário não foi encontrado");
}
bool erro = false;
string mensagens = "";
foreach (var x in modelo)
{
try
{
if (email)
{
MailServices.Enviar(x.Usuario.EmailPreferencial, "Faz tempo que você não lança suas atividades", string.Format("Detectamos que faz {0} dias que você não lança suas atividades. Por favor lance hoje.", x.DiasUteisSemLancar));
}
}
catch (Exception err)
{
erro = true;
mensagens += "Ocorreu um erro ao enviar o alerta via e-mail para " + x.Usuario.Login + ": " + err.Message + "<br/>\r\n";
LogServices.LogarException(err);
}
string smsResult = "";
try
{
if (sms && x.Usuario.Funcionario != null && !string.IsNullOrWhiteSpace(x.Usuario.Funcionario.Celular))
{
smsResult = SMSServices.Enviar(x.Usuario.Funcionario.Celular, x.Usuario.FuncionarioNomeOuLogin, "Faz tempo que você não lança suas atividades", string.Format("Detectamos que faz {0} dias que você não lança suas atividades. Por favor lance hoje.", x.DiasUteisSemLancar));
LogServices.Logar(smsResult);
}
}
catch (Exception err)
{
erro = true;
mensagens += "Ocorreu um erro ao enviar o alerta via sms para " + x.Usuario.Login + ": " + err.Message + "<br/>\r\n";
LogServices.LogarException(err);
}
}
if (erro)
{
throw new Exception("Erros ocorridos: " + mensagens);
}
}
/// <summary>
/// método estático independente com context próprio para ser executado em jobs
/// </summary>
public static void AtualizaAcoesCopiandoDoAssembly()
{
try
{
Type tipo = Type.GetType("TPA.Presentation.Controllers.TPAController, TPA.Presentation");
using (TPAContext db = new TPAContext())
{
AcaoServices g = new AcaoServices(db);
g.ImportarDoAssembly(tipo);
g.AtualizaAdmin();
}
}
catch (Exception err)
{
LogServices.LogarException(err);
}
}
public async Task <JsonResult> AdicionarRecursos(NodeUsuariosViewModel nuvm)
{
UsuarioApplication usuApp = new UsuarioApplication(this.db);
try
{
await usuApp.RemoverUsuariosForaDaLista(nuvm.IdNode, nuvm.IdsUsuarios, nuvm.AdicionarRecursivo);
if (nuvm.IdsUsuarios != null && nuvm.IdsUsuarios.Count > 0)
{
foreach (int usu in nuvm.IdsUsuarios)
{
await usuApp.AdicionarNodeAsync(new UsuarioNodeViewModel
{
AdicionarRecursivo = nuvm.AdicionarRecursivo,
IdNode = nuvm.IdNode,
IdUsuario = usu
});
}
return(Json(new
{
Sucesso = true,
Mensagem = "Recursos adicionados com sucesso."
}));
}
else
{
return(Json(new
{
Sucesso = true,
Mensagem = "Recursos removidos com sucesso."
}));
}
}
catch (Exception err)
{
LogServices.LogarException(err);
return(Json(new
{
Sucesso = false,
Mensagem = err.Message
}));
}
}
/// <summary>
/// Evia o alerta de lançamento em atraso para um usuário
/// </summary>
/// <param name="idUsuario">id do usuário que vai receber o alerta</param>
/// <param name="email">boolean - se vai receber por e-mail ou não</param>
/// <param name="sms">boolean - se vai receber por sms ou não</param>
/// <param name="telegram">boolean - se vai receber por telegram ou não</param>
/// <returns></returns>
public virtual void EnviarAlerta(int idUsuario, bool email = true, bool sms = false)
{
string smsResult = "";
if (idUsuario == 0)
{
throw new Exception("O usuário não foi informado");
}
var modelo = this.GetUltimosLancamentosById(idUsuario);
if (modelo == null)
{
throw new Exception("O usuário não foi encontrado");
}
try
{
if (email)
{
MailServices.Enviar(modelo.Usuario.EmailPreferencial, "Faz tempo que você não lança suas atividades", string.Format("Detectamos que faz {0} dias que você não lança suas atividades. Por favor lance hoje.", modelo.DiasUteisSemLancar));
}
}
catch (Exception err)
{
LogServices.LogarException(err);
throw new Exception("Erro ao enviar email: " + err.Message, err);
}
try
{
if (sms && modelo.Usuario.Funcionario != null && !string.IsNullOrWhiteSpace(modelo.Usuario.Funcionario.Celular))
{
smsResult = SMSServices.Enviar(modelo.Usuario.Funcionario.Celular, modelo.Usuario.FuncionarioNomeOuLogin, "Faz tempo que você não lança suas atividades", string.Format("Detectamos que faz {0} dias que você não lança suas atividades. Por favor lance hoje.", modelo.DiasUteisSemLancar));
LogServices.Logar(smsResult);
}
}
catch (Exception err)
{
LogServices.LogarException(err);
throw new Exception("Erro ao enviar sms: " + err.Message, err);
}
}
/// <summary>
/// dispara alertas de atraso nas atividades diariamente
/// </summary>
public static void EnviaAlertasAgendados()
{
try
{
if (!DevServices.IsDevEnv())
{
using (var db = new TPAContext())
{
UsuarioApplication usuApp = new UsuarioApplication(db);
usuApp.EnviarTodosOsAlertas(true, true);
}
}
}
catch (Exception err)
{
LogServices.LogarException(err);
}
}
public ActionResult Index(FormCollection formCollection)
{
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
if (Request != null)
{
HttpPostedFileBase file = Request.Files["UploadedFile"];
if ((file != null) && (file.ContentLength > 0) && !string.IsNullOrEmpty(file.FileName) && (Path.GetExtension(file.FileName).ToUpper() == ".XLSX"))
{
string fileName = file.FileName;
string fileContentType = file.ContentType;
using (var package = new ExcelPackage(file.InputStream))
{
try
{
ImportaPlanilhaApplication app = new ImportaPlanilhaApplication(this.db);
var planilha = app.TransformarPlanilhaAdmin(package);
return(View("LancaPlanilha", planilha));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.ToString(), TempData, ModelState);
LogServices.LogarException(err);
}
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Faça o upload de uma planilha de horários em excel .xlsx no padrão da Tecnun.", TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Ocorreu algum erro e o request está nulo", TempData, ModelState);
}
return(View("Index"));
}
/// <summary>
/// copia para a ExcelWorksheet os dados de GetRelatorio_Horas_Projeto
/// </summary>
/// <param name="dtIni">DateTime - data inicial</param>
/// <param name="dtFin">DateTime - data final</param>
/// <param name="ws">ExcelWorksheet - worksheet do pacote epplus para onde vão os dados</param>
private void ConstroiRelatorio_Horas_Projeto(DateTime dtIni, DateTime dtFin, ExcelWorksheet ws)
{
var dados = this.GetRelatorio_Horas_Projeto(dtIni, dtFin);
int linha = 6;
ws.Column(2).Style.Numberformat.Format = "[hh]:mm";
foreach (var d in dados)
{
try
{
ws.Cells[linha, 1].Value = d.Projeto;
ws.Cells[linha, 2].Value = d.Horas;
linha++;
}
catch (Exception err)
{
LogServices.LogarException(err);
}
}
}
public async Task <JsonResult> Mover(int id, int idNovoPai, int posicao)
{
if ((id == 0) || (id == idNovoPai))
{
return(Json(new
{
Sucesso = false,
Mensagem = "O objeto não pode ser movido."
}));
}
try
{
var node = await db.ProjectNodes.FindAsync(id);
var novoPai = await db.ProjectNodes.FindAsync(idNovoPai);
node.Pai = novoPai;
await db.SaveChangesAsync();
return(Json(new
{
Sucesso = true,
Mensagem = "Movido com sucesso."
}));
}
catch (Exception err)
{
LogServices.LogarException(err);
return(Json(new
{
Sucesso = false,
Mensagem = err.Message
}));
}
}
public ActionResult Index(FormCollection formCollection)
{
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
if (Request != null)
{
if (formCollection["IdUsuario"] != null)
{
int IdUsuario = TFWConvert.ToInteger(formCollection["IdUsuario"]);
if (IdUsuario > 0)
{
HttpPostedFileBase file = Request.Files["UploadedFile"];
if ((file != null) && (file.ContentLength > 0) && !string.IsNullOrEmpty(file.FileName) && (Path.GetExtension(file.FileName).ToUpper() == ".XLSX"))
{
string fileName = file.FileName;
string fileContentType = file.ContentType;
//byte[] fileBytes = new byte[file.ContentLength];
//var data = file.InputStream.Read(fileBytes, 0, Convert.ToInt32(file.ContentLength));
using (var package = new ExcelPackage(file.InputStream))
{
try
{
ImportaPlanilhaApplication app = new ImportaPlanilhaApplication(this.db);
var planilha = app.TransformarPlanilhaUsuario(IdUsuario, package);
return(View("LancaPlanilha", planilha));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
LogServices.LogarException(err);
}
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Faça o upload de uma planilha de horários em excel .xlsx no padrão da Tecnun.", TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Selecione um usuário válido", TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi encontrado o Id do Usuário", TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Ocorreu algum erro e o request está nulo", TempData, ModelState);
}
return(View("Index"));
}
/// <summary>
/// posta os dados retirados da planilha e trabalhados no ImportacaoPlanilhaAtividadesViewModel
/// </summary>
/// <param name="planilha">ImportacaoPlanilhaAtividadesViewModel - viewmodel com os dados estruturados e editados para inserção no banco de dados</param>
/// <returns>int - quantidade de atividades importadas</returns>
public virtual async Task <int> LancarAsync(ImportacaoPlanilhaAtividadesViewModel planilha)
{
int result = 0;
CalendarioServices cal = new CalendarioServices();
AtividadeApplication app = new AtividadeApplication(this._db);
foreach (var i in planilha.Itens)
{
try
{
if ((i.Data != null) && (i.Data != DateTime.MinValue) && (cal.IsDiaUtil(i.Data)))
{
var projeto = await this._db.ProjectNodes.FindAsync(i.IdProjeto);
var tipo = await this._db.TiposAtividade.FindAsync(i.IdTipoAtividade);
if (planilha is ImportacaoPlanilhaAtividadesUsuarioViewModel)
{
i.IdUsuario = (planilha as ImportacaoPlanilhaAtividadesUsuarioViewModel).IdUsuario;
}
Usuario usuario = await this._db.Usuarios.FindAsync(i.IdUsuario);
if (usuario == null)
{
throw new Exception("Usuário da planilha não preenchido");
}
if (i.EntradaManha != null && i.SaidaManha != null && i.EntradaTarde != null && i.SaidaTarde != null)
{
if (i.EntradaManha > i.SaidaManha)
{
throw new Exception("A entrada do primeiro horário não pode ser maior que a saída do primeiro horário");
}
if (i.EntradaTarde > i.SaidaTarde)
{
throw new Exception("A entrada do segundo horário não pode ser maior que a saída do segundo horário");
}
if (i.EntradaManha > i.SaidaTarde)
{
throw new Exception("A entrada do primeiro horário não pode ser maior que a saída do segundo horário");
}
if (i.SaidaManha > i.EntradaTarde)
{
throw new Exception("A saída do primeiro horário não pode ser maior que a entrada do segundo horário");
}
}
if ((i.EntradaManha != null) && (i.SaidaManha != null) && (i.SaidaManha > i.EntradaManha))
{
await app.SalvarAsync(new Atividade
{
Observacao = i.Descricao,
Inicio = i.Data.AddHours(i.EntradaManha.Value.Hours).AddMinutes(i.EntradaManha.Value.Minutes),
Fim = i.Data.AddHours(i.SaidaManha.Value.Hours).AddMinutes(i.SaidaManha.Value.Minutes),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = usuario
}, false);
}
if ((i.EntradaTarde != null) && (i.SaidaTarde != null) && (i.SaidaTarde > i.EntradaTarde))
{
await app.SalvarAsync(new Atividade
{
Observacao = i.Descricao,
Inicio = i.Data.AddHours(i.EntradaTarde.Value.Hours).AddMinutes(i.EntradaTarde.Value.Minutes),
Fim = i.Data.AddHours(i.SaidaTarde.Value.Hours).AddMinutes(i.SaidaTarde.Value.Minutes),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = usuario
}, false);
}
}
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
throw new Exception("Problemas com a validação das entities: " + exceptionMessage, ex);
}
catch (Exception err)
{
LogServices.LogarException(err);
throw new Exception("Erro: " + err.Message, err);
}
finally
{
result++;
}
}
return(result);
}