public PactoViewModel Atualizar(PactoViewModel pactoViewModel, UsuarioViewModel usuario, eAcaoPacto eAcao)
{
BeginTransaction();
bool isDirigente = usuario.IsDirigente;
CriaHistoricoAcaoEmPacto(pactoViewModel, isDirigente, usuario, eAcao);
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoViewModel);
TratarSituacaoPactoAtualizacao(pactoViewModel, usuario, eAcao, isDirigente, pacto);
var pactoReturn = _pactoService.Atualizar(pacto, pacto.IdPacto);
if (pactoReturn.ValidationResult.IsValid)
{
var acao = "";
if (pactoViewModel.Acao == "Assinando")
{
pactoReturn.ValidationResult.Message = Mensagens.MS_004;
acao = Domain.Enums.Operacao.Assinatura.ToString();
}
else
{
pactoReturn.ValidationResult.Message = Mensagens.MS_006;
acao = Domain.Enums.Operacao.Alteração.ToString();
}
_logService.Logar(pacto, usuario.CPF, acao);
Commit();
}
pactoViewModel = Mapper.Map <Pacto, PactoViewModel>(pactoReturn);
return(pactoViewModel);
}
public RelatorioAlSimultaneaViewModel RetornaRelatorioAlocacaoSimultanea(SearchFlPontoViewModel searchFl)
{
var rltAlcSilmu = new RelatorioAlSimultaneaViewModel();
rltAlcSilmu.searchSimultanea = new SearchFlPontoViewModel();
rltAlcSilmu.lstPactos = new List <PactoViewModel>();
rltAlcSilmu.listDates = new List <DateTime>();
rltAlcSilmu.lisQtdServidor = new List <QuantidadeServidorViewModel>();
var lisIntUnidades = new List <int>();
var pct = new PactoViewModel();
ObterUnidadesEPactosRelatorioAlocacaoSimultanea(searchFl, rltAlcSilmu, pct);
if (searchFl.UnidadeId == null || searchFl.UnidadeId == 0)
{
FiltrarRelatorioAlocacaoSimultaneaPorUnidade(rltAlcSilmu, lisIntUnidades);
}
else
{
var qtdServidor = new QuantidadeServidorViewModel();
qtdServidor.idUnidade = searchFl.UnidadeId.Value;
qtdServidor.qtdServidorUnidade = _Usuarioservice.ObterTodos(searchFl.UnidadeId.Value).Count();
rltAlcSilmu.lisQtdServidor.Add(qtdServidor);
}
CalcularDatasRelatorioAlocacaoSimultanea(rltAlcSilmu);
return(rltAlcSilmu);
}
public void TestSuspender()
{
InitializaNinject();
var pactoAppService = kernel.Get <IPactoAppService>();
var usuarioAppService = kernel.Get <IUsuarioAppService>();
var usuario = _usuarioService.ObterPorCPF("02941397450");
var os = _osService.ObterOrdemVigente();
var pacto = new PactoViewModel
{
Nome = "Francir Borges Silvério",
MatriculaSIAPE = "123456",
UnidadeExercicio = 5,
TelefoneFixoServidor = "(11) 11111-1111",
TelefoneMovelServidor = "(22) 22222-2222",
PossuiCargaHoraria = false,
DataPrevistaInicio = DateTime.Now,
DataPrevistaTermino = DateTime.Now.AddDays(10),
CargaHorariaTotal = 190,
IdSituacaoPacto = 1,
CpfUsuario = usuario.CPF,
IdOrdemServico = os.IdOrdemServico,
CargaHorariaDiaria = TimeSpan.FromHours(8),
CpfUsuarioCriador = usuario.CPF,
IdTipoPacto = 1
};
var userAssinante = usuarioAppService.ObterPorCPF("11391275861");
var resultado = pactoAppService.AtualizarStatus(pacto, userAssinante, Enums.eAcaoPacto.Suspendendo, true);
Assert.AreEqual((int)Enums.eSituacaoPacto.Suspenso, resultado.IdSituacaoPacto);
Assert.IsTrue(resultado.ValidationResult.Message.Contains("sucesso"));
}
private static string MontarTextoTabelaProdutos(PactoViewModel p)
{
List <string> lstDadosProdutos = new List <string>();
p.Produtos.ToList().ForEach(prod =>
{
var tsCarga = TimeSpan.FromHours((double)prod.CargaHorariaProduto * prod.QuantidadeProduto);
string minutes = tsCarga.Minutes < 10 ? "0" + tsCarga.Minutes : tsCarga.Minutes.ToString();
string cargaHorariaProdutoFormatada = $"{Math.Floor(tsCarga.TotalHours)}:{minutes}";
StringBuilder strDadosProdutos = new StringBuilder();
strDadosProdutos.Append(prod.GrupoAtividade.NomGrupoAtividade)
.Append(";")
.Append(prod.Atividade.NomAtividade)
.Append(";")
.Append(prod.TipoAtividade.Faixa)
.Append(";")
.Append(prod.QuantidadeProduto)
.Append(";")
.Append(cargaHorariaProdutoFormatada);
lstDadosProdutos.Add(strDadosProdutos.ToString());
});
String tabelaProdutos = MontarTabelaDadosProdutos(lstDadosProdutos);
return(tabelaProdutos);
}
public bool PodeCancelarAvaliacao(PactoViewModel pactoVM, UsuarioViewModel user, bool isDirigente, bool unidadePactoESubordinadaUnidadeUsuario)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoVM);
var usr = Mapper.Map <UsuarioViewModel, Usuario>(user);
return((!isDirigente || pacto.UnidadeExercicio == user.IdUnidadeSelecionada) && _pactoService.PodeCancelarAvaliacao(pacto, usr, isDirigente, unidadePactoESubordinadaUnidadeUsuario));
}
public bool PodeEditarObservacaoProduto(PactoViewModel pacto, UsuarioViewModel usuariologado, bool isDirigente, bool unidadePactoEhSubordinadaUnidadeUsuario)
{
var pactoVM = Mapper.Map <PactoViewModel, Pacto>(pacto);
var usr = Mapper.Map <UsuarioViewModel, Usuario>(usuariologado);
return((!isDirigente || pacto.UnidadeExercicio == usuariologado.IdUnidadeSelecionada) && _pactoService.PodeEditarObservacaoProduto(pactoVM, usr, isDirigente, unidadePactoEhSubordinadaUnidadeUsuario));
}
public PactoViewModel CancelarAvaliacao(PactoViewModel pactoVM, AvaliacaoProdutoViewModel avaliacaoProdutoVM, UsuarioViewModel user, eAcaoPacto acao)
{
BeginTransaction();
CriaHistoricoAcaoEmPacto(pactoVM, user.IsDirigente, user, acao);
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoVM);
var usr = Mapper.Map <UsuarioViewModel, Usuario>(user);
pacto.DataTerminoReal = null;
pacto.EntregueNoPrazo = null;
var produto = pacto.Produtos.FirstOrDefault(p => p.IdProduto == avaliacaoProdutoVM.IdProduto);
var avaliacaoProduto = produto.Avaliacoes.FirstOrDefault(ap => ap.IdAvaliacaoProduto == avaliacaoProdutoVM.IdAvaliacaoProduto);
_avaliacaoProdutoService.Remover(avaliacaoProduto);
produto.Avaliacoes.Remove(avaliacaoProduto);
pacto = _pactoService.AtualizarStatus(pacto, usr, acao, user.IsDirigente);
if (pacto.ValidationResult.IsValid)
{
_logService.Logar(pacto, user.CPF, Domain.Enums.Operacao.Alteração.ToString());
Commit();
}
pactoVM = Mapper.Map <Pacto, PactoViewModel>(pacto);
return(pactoVM);
}
public bool PodeVisualizar(PactoViewModel pactoVM, UsuarioViewModel usuarioVM, bool isDirigente, bool unidadePactoESubordinadaUnidadeUsuario)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoVM);
var usuario = Mapper.Map <UsuarioViewModel, Usuario>(usuarioVM);
return(_pactoService.PodeVisualizar(pacto, usuario, isDirigente, unidadePactoESubordinadaUnidadeUsuario));
}
private void TratarHistoricoRestricaoVisualizacao(PactoViewModel pacto, UsuarioViewModel user, eAcaoPacto acao, List <string> lstHistorico, string strPerfil)
{
if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Assinando || (int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Editando || (int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Criando)
{
bool registrarHistoricoPacto = false;
if (pacto.IdPacto > 0)
{
var pactoAtual = _pactoService.BuscarPorId(pacto.IdPacto);
registrarHistoricoPacto = pactoAtual.IndVisualizacaoRestrita != pacto.IndVisualizacaoRestrita;
}
else
{
registrarHistoricoPacto = pacto.IndVisualizacaoRestrita;
}
if (registrarHistoricoPacto)
{
if (pacto.IndVisualizacaoRestrita)
{
lstHistorico.Add("Plano de Trabalho marcado como reservado por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília");
}
else
{
lstHistorico.Add("Excluída a marcação de Plano de Trabalho reservado por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília");
}
}
}
}
public void EnviarEmailNotificacaoFinalizacaoPacto(PactoViewModel p)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
string tabelaProdutos = MontarTextoTabelaProdutos(p);
string linkPacto = ObterLinkPacto(p);
List <Usuario> lstDestinatarios = _usuarioService.ObterDirigentesUnidade(Convert.ToInt32(p.UnidadeExercicio)).ToList();
lstDestinatarios.Add(Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario)));
bool montouMensagem = true;
lstDestinatarios.ForEach(u =>
{
String nomeDirigente = u.Nome;
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataInicioPacto = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPacto = p.DataPrevistaTermino?.ToString("dd/MM/yyyy");
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_FIM_PACTO,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
dataInicioPacto,
dataTerminoPacto,
tabelaProdutos,
"<a href='" + linkPacto + "'> aqui </a>"
);
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_FIM_PACTO,
numeroPacto,
nomeServidor);
destinatario = u.Email;
}
catch (Exception ex)
{
// LogManagerComum.LogarErro(ex, null, "Email ao montar email de finalização do pacto = " + numeroPacto);
montouMensagem = false;
}
try
{
if (montouMensagem)
{
new EmailCGU().EnviarEmail(mensagem, assunto, destinatario);
}
}
catch (Exception ex)
{
// LogManagerComum.LogarErro(ex, null, " Email não enviado. Detalhe: Para: " + destinatario + "\n Assunto: " + assunto + "\n Mensagem: " + mensagem);
}
});
}
private void MontarEEnviarNotificacaoInclusaoPelaChefiaPacto(PactoViewModel p)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
String tabelaProdutos = MontarTextoTabelaProdutos(p);
String linkPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/" + p.IdPacto;
// Destinatários dos emails:
// 1) Dirigente que fez o pacto
// 2) O usuário do pacto
var lstDestinatarios = new List <Usuario>();
Usuario chefeQueCriou = Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuarioCriador));
lstDestinatarios.Add(chefeQueCriou);
lstDestinatarios.Add(Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario)));
lstDestinatarios.ForEach(u =>
{
bool montouMensagem = true;
String nomeDirigente = chefeQueCriou.Nome;
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataInicioPacto = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPacto = p.DataPrevistaTermino?.ToString("dd/MM/yyyy");
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_INCLUSAO_PACTO_PELA_CHEFIA,
nomeDirigente,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
dataInicioPacto,
dataTerminoPacto,
tabelaProdutos,
"<a href='" + linkPacto + "'> aqui </a>"
);
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_INCLUSAO_PACTO_PELA_CHEFIA,
nomeDirigente,
numeroPacto,
nomeServidor
);
destinatario = u.Email;
}
catch (Exception ex)
{
//LogManagerComum.LogarErro(ex, null, "Erro ao montar email de inclusão por chefia do pacto = " + numeroPacto);
montouMensagem = false;
}
EnviarEmail(assunto, mensagem, destinatario, montouMensagem);
});
}
public IEnumerable <PactoViewModel> ObterTodos(PactoViewModel objFiltro, bool incluirUnidadesSubordinadas)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(objFiltro);
var retorno = _pactoService.ConsultarPactos(pacto, incluirUnidadesSubordinadas);
var dest = MapeiaSemProdutos(retorno);
return(dest);
}
private void MontarEEnviarNotificacaoVoltandoSuspensao(PactoViewModel p, UsuarioViewModel usuarioLogado)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
String tabelaProdutos = MontarTextoTabelaProdutos(p);
String linkPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/" + p.IdPacto;
// Destinatários dos emails:
//1) Próprio solicitante
var solicitante = Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario));
bool montouMensagem = true;
Usuario chefeQueReiniciou = Mapper.Map <UsuarioViewModel, Usuario>(usuarioLogado);
String dataSuspensao = p.SuspensoAPartirDe?.ToString("dd/MM/yyyy");
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataInicioPacto = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPacto = p.DataPrevistaTerminoAntesSuspensao?.ToString("dd/MM/yyyy");
String dataInicioPactoAposReativacao = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPactoAposReativacao = p.DataPrevistaTermino?.ToString("dd/MM/yyyy");
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_PACTO_REINICIADO_APOS_SUSPENSAO,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
chefeQueReiniciou.Nome,
dataInicioPacto,
dataTerminoPacto,
dataSuspensao,
dataInicioPactoAposReativacao,
dataTerminoPactoAposReativacao,
tabelaProdutos,
"<a href='" + linkPacto + "'> aqui </a>",
DateTime.Now.ToString("dd/MM/yyyy 'às' HH:mm:ss"),
p.SituacaoPactoDescricao
);
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_PACTO_REINICIADO_APOS_SUSPENSAO,
numeroPacto,
nomeServidor,
chefeQueReiniciou.Nome
);
destinatario = solicitante.Email;
}
catch (Exception ex)
{
//LogManagerComum.LogarErro(ex, null, "Erro ao montar email de reinício após suspensão do pacto = " + numeroPacto);
throw;
}
EnviarEmail(assunto, mensagem, destinatario, montouMensagem);
}
private void MontarEEnviarNotificacaoInterrupcaoPacto(PactoViewModel p, UsuarioViewModel usuarioLogado)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
String tabelaProdutos = MontarTextoTabelaProdutos(p);
String linkPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/" + p.IdPacto;
// Destinatários dos emails:
//1) Próprio solicitante
var solicitante = Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario));
bool montouMensagem = true;
Usuario chefeQueInterrompeu = Mapper.Map <UsuarioViewModel, Usuario>(usuarioLogado);
String dataInterrupcao = p.DataInterrupcao?.ToString("dd/MM/yyyy");
String motivo = p.Motivo;
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataInicioPacto = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPacto = p.DataPrevistaTermino?.ToString("dd/MM/yyyy");
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_INTERRUPCAO_PACTO,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
chefeQueInterrompeu.Nome,
dataInicioPacto,
dataTerminoPacto,
dataInterrupcao,
motivo,
tabelaProdutos,
numeroPacto,
"<a href='" + linkPacto + "'> aqui </a>"
);
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_INTERRUPCAO_PACTO,
numeroPacto,
nomeServidor,
chefeQueInterrompeu.Nome
);
destinatario = solicitante.Email;
}
catch (Exception ex)
{
//LogManagerComum.LogarErro(ex, null, "Email ao montar email de interrupção do pacto = " + numeroPacto);
throw;
}
EnviarEmail(assunto, mensagem, destinatario, montouMensagem);
}
private void MontarEEnviarNotificacaoAlteracaoEmAndamentoPacto(PactoViewModel p)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
String tabelaProdutos = MontarTextoTabelaProdutos(p);
String linkPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/" + p.IdPacto;
var dirigentes = _usuarioService.ObterDirigentesUnidade(Convert.ToInt32(p.UnidadeExercicio)).ToList();
// Destinatários dos emails:
// 1) Dirigentes
// 2) Próprio solicitante
var lstDestinatarios = dirigentes;
lstDestinatarios.Add(Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario)));
lstDestinatarios.ForEach(u =>
{
bool montouMensagem = true;
String nomeDirigente = u.Nome;
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataInicioPacto = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPacto = p.DataPrevistaTermino?.ToString("dd/MM/yyyy");
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_ALTERACAO_PACTO_EM_ANDAMENTO,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
dataInicioPacto,
dataTerminoPacto,
tabelaProdutos,
"<a href='" + linkPacto + "'> aqui </a>"
);
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_ALTERACAO_PACTO,
numeroPacto,
nomeServidor
);
destinatario = u.Email;
}
catch (Exception ex)
{
//LogManagerComum.LogarErro(ex, null, "Erro ao montar email de alteração do pacto = " + numeroPacto);
montouMensagem = false;
}
EnviarEmail(assunto, mensagem, destinatario, montouMensagem);
});
}
public PactoViewModel ZeraRestanteCronograma(PactoViewModel pacto)
{
pacto.Cronogramas.ForEach(x =>
{
if (x.DataCronograma > pacto.SuspensoAPartirDe)
{
x.HorasCronograma = TimeSpan.Zero;
}
});
return(pacto);
}
public void EnviarEmailNotificacaoReativacaoAutomaticaPacto(PactoViewModel p)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
string tabelaProdutos = MontarTextoTabelaProdutos(p);
String linkPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/" + p.IdPacto;
List <Usuario> lstDestinatarios = _usuarioService.ObterDirigentesUnidade(Convert.ToInt32(p.UnidadeExercicio)).ToList();
lstDestinatarios.Add(Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario)));
String dataSuspensao = p.SuspensoAPartirDe?.ToString("dd/MM/yyyy");
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataInicioPacto = p.DataPrevistaInicio.ToString("dd/MM/yyyy");
String dataTerminoPacto = p.DataPrevistaTermino?.ToString("dd/MM/yyyy");
String situacaoPacto = _situacaoPactoService.ObterPorId(p.IdSituacaoPacto)?.DescSituacaoPacto;
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_PACTO_REINICIADO_AUTOMATICAMENTE,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
DateTime.Now.ToString("dd/MM/yyyy 'às' HH:mm:ss"),
dataInicioPacto,
dataTerminoPacto,
dataSuspensao,
tabelaProdutos,
situacaoPacto,
"<a href='" + linkPacto + "'> aqui </a>");
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_PACTO_REINICIADO_AUTOMATICAMENTE,
numeroPacto,
nomeServidor);
string destinatarios = string.Join(";", lstDestinatarios.Select(u => u.Email).ToList());
try
{
new EmailCGU().EnviarEmail(mensagem, assunto, destinatarios);
}
catch (Exception ex)
{
// Nada a fazer, apenas loga. Futuramente podem-se armazenar os emails que falharam e tentar reenviar
// LogManagerComum.LogarErro(ex, null, " Email não enviado. Detalhe: Para: " + destinatario + "\n Assunto: " + assunto + "\n Mensagem: " + mensagem);
}
}
catch (Exception ex)
{
// LogManagerComum.LogarErro(ex, null, " Email ao montar email de reativação automática do pacto = " + numeroPacto);
}
}
private void AdicionarListaHistoricos(PactoViewModel pacto, List <string> lstHistorico)
{
if (lstHistorico.Any())
{
lstHistorico.ForEach(h =>
{
var historico = new HistoricoViewModel()
{
IdPacto = pacto.IdPacto, Descricao = h
};
var historicoVM = Mapper.Map <HistoricoViewModel, Historico>(historico);
_historicoService.Adicionar(historicoVM);
});
}
}
private void MontarEEnviarNotificacaoAvaliacaoParcialPactoPelaChefia(PactoViewModel p, UsuarioViewModel usuarioLogado, AvaliacaoProdutoViewModel apvm)
{
String assunto = "";
String mensagem = "";
String destinatario = "";
String linkPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/" + p.IdPacto;
var solicitante = Mapper.Map <UsuarioViewModel, Usuario>(_usuarioAppService.ObterPorCPF(p.CpfUsuario));
bool montouMensagem = true;
Usuario chefeQueAvaliou = Mapper.Map <UsuarioViewModel, Usuario>(usuarioLogado);
String nomeServidor = p.Nome;
String numeroPacto = p.IdPacto.ToString();
String dataAvaliacaoPacto = DateTime.Now.ToString("dd/MM/yyyy");
String horaAvaliacaoPacto = DateTime.Now.ToString("hh:mm");
try
{
mensagem = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.CORPO_EMAIL_NOTIFICACAO_AVALIACAO_PARCIAL_PACTO_PELA_CHEFIA,
"<a href='" + linkPacto + "'>" + numeroPacto + "</a>",
nomeServidor,
chefeQueAvaliou.Nome, chefeQueAvaliou.NomeUnidade,
dataAvaliacaoPacto,
horaAvaliacaoPacto,
apvm.QuantidadeProdutosAvaliados, apvm.Produto.Atividade.NomAtividade,
apvm.CargaHorariaAvaliadaFormatada, apvm.Avaliacao,
"<a href='" + linkPacto + "'> aqui </a>"
);
assunto = String.Format(PGD.Infra.CrossCutting.Util.Properties.Resources.ASSUNTO_EMAIL_NOTIFICACAO_AVALIACAO_PARCIAL_PACTO_PELA_CHEFIA,
numeroPacto,
nomeServidor,
chefeQueAvaliou.Nome
);
destinatario = solicitante.Email;
}
catch (Exception ex)
{
//LogManagerComum.LogarErro(ex, null, "Erro ao montar email de suspensão do pacto = " + numeroPacto);
throw;
}
EnviarEmail(assunto, mensagem, destinatario, montouMensagem);
}
public PactoViewModel Adicionar(PactoViewModel pactoViewModel, bool isDirigente, UsuarioViewModel usuarioViewModel)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoViewModel);
BeginTransaction();
var pactoReturn = _pactoService.Adicionar(pacto);
if (pactoReturn.ValidationResult.IsValid)
{
CriaHistoricoAcaoEmPacto(pactoViewModel, isDirigente, usuarioViewModel, eAcaoPacto.Criando);
Commit();
_logService.Logar(pacto, pactoViewModel.CpfUsuarioCriador, Domain.Enums.Operacao.Inclusão.ToString());
Commit();
}
pactoViewModel = Mapper.Map <Pacto, PactoViewModel>(pactoReturn);
return(pactoViewModel);
}
public PactoViewModel Remover(PactoViewModel pactoViewModel, UsuarioViewModel usuariologado)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoViewModel);
pacto.IdSituacaoPacto = (int)eSituacaoPacto.Excluido;
BeginTransaction();
var pactoReturn = _pactoService.Atualizar(pacto);
if (pactoReturn.ValidationResult.IsValid)
{
pactoViewModel.ValidationResult.Message = PGD.Domain.Constantes.Mensagens.MS_008;
_logService.Logar(pacto, usuariologado.CPF, Domain.Enums.Operacao.Alteração.ToString());
Commit();
}
pactoViewModel = Mapper.Map <Pacto, PactoViewModel>(pactoReturn);
return(pactoViewModel);
}
private void TratarHistoricoDeAssinatura(PactoViewModel pacto, bool isDirigente, UsuarioViewModel user, List <string> lstHistorico, string strPerfil)
{
var nome_usuario = _usuarioService.ObterPorCPF(user.CpfUsuario).Nome;
var nome_unidade = _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome;
var data_atual = DateTime.Now.ToShortDateString();
var hora_atual = DateTime.Now.ToLongTimeString();
lstHistorico.Add("Plano de Trabalho assinado eletronicamente por " + nome_usuario + "," + strPerfil + ", na unidade " + nome_unidade + ", em " + data_atual + ", às " + hora_atual + ", conforme horário oficial de Brasília.");
if (isDirigente)
{
pacto.CpfUsuarioDirigente = user.CpfUsuario;
pacto.DataAprovacaoDirigente = DateTime.Now;
pacto.StatusAprovacaoDirigente = 1;
}
else
{
pacto.CpfUsuarioSolicitante = pacto.CpfUsuario;
pacto.DataAprovacaoSolicitante = DateTime.Now;
pacto.StatusAprovacaoSolicitante = 1;
}
}
private static void TratarSituacaoPactoAtualizacaoAssinando(PactoViewModel pactoViewModel, UsuarioViewModel usuario, eAcaoPacto eAcao, bool isDirigente, Pacto pacto)
{
if (eAcao == eAcaoPacto.Assinando && pactoViewModel.DataPrevistaInicio > DateTime.Today && (!isDirigente && pacto.StatusAprovacaoDirigente == 1 || (isDirigente && pacto.StatusAprovacaoSolicitante == 1)))
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.AIniciar;
}
if (eAcao == eAcaoPacto.Assinando && pactoViewModel.DataPrevistaInicio <= DateTime.Today)
{
if (isDirigente && pacto.StatusAprovacaoSolicitante == 1 || !isDirigente && pacto.StatusAprovacaoDirigente == 1)
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.EmAndamento;
}
if (isDirigente && pactoViewModel.StatusAprovacaoDirigente == null)
{
pacto.StatusAprovacaoDirigente = 1;
pacto.DataAprovacaoDirigente = DateTime.Today;
pacto.CpfUsuarioDirigente = usuario.CPF;
}
}
}
public System.ComponentModel.DataAnnotations.ValidationResult ValidarDataConclusaoAntecipada(PactoViewModel pacto, DateTime dataConclusaoAntecipada)
{
return(_pactoService.ValidarDataConclusaoAntecipada(Mapper.Map <Pacto>(pacto), dataConclusaoAntecipada));
}
public System.ComponentModel.DataAnnotations.ValidationResult ValidarDataHoraSuspensaoInterrupcao(PactoViewModel pactoVM, DateTime dataInicioSuspensao, TimeSpan horasConsideradas, Domain.Enums.Operacao operacao)
{
return(_pactoService.ValidarDataHoraSuspensaoInterrupcao(Mapper.Map <Pacto>(pactoVM), dataInicioSuspensao, horasConsideradas, operacao));
}
public PactoViewModel OrdemVigenteProdutos(OrdemServicoViewModel ordemVigente, PactoViewModel pacto)
{
pacto.OrdemServico = ordemVigente;
foreach (var produto in pacto.Produtos)
{
produto.GrupoAtividade = ordemVigente.Grupos.FirstOrDefault(x => x.IdGrupoAtividade == produto.IdGrupoAtividade);
produto.Atividade = produto.GrupoAtividade.Atividades.FirstOrDefault(x => x.IdAtividade == produto.IdAtividade);
produto.TipoAtividade = produto.Atividade.Tipos.FirstOrDefault(x => x.IdTipoAtividade == produto.IdTipoAtividade);
}
return(pacto);
}
public int BuscaStatusAssinatura(PactoViewModel objFiltro)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(objFiltro);
return(_pactoService.BuscaStatusAssinatura(pacto));
}
public bool PodeVisualizarPactuadoAvaliado(PactoViewModel pactoVM)
{
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoVM);
return(_pactoService.PodeVisualizarPactuadoAvaliado(pacto));
}
public PactoViewModel CriaHistoricoAcaoEmPacto(PactoViewModel pacto, bool isDirigente, UsuarioViewModel user, eAcaoPacto acao)
{
List <string> lstHistorico = new List <string>();
string strPerfil = ObterDescricaoPerfilUsuario(isDirigente, user);
if (VerificarSeDeveCriarHistoricoDeAssinatura(acao))
{
TratarHistoricoDeAssinatura(pacto, isDirigente, user, lstHistorico, strPerfil);
}
else if ((int)PGD.Domain.Enums.eAcaoPacto.Interrompendo == (int)acao)
{
lstHistorico.Add("Plano de Trabalho interrompido por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + ", em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília. Motivo: " + pacto.Motivo);
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Avaliando)
{
lstHistorico.Add("Plano de Trabalho avaliado por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília.");
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.AvaliandoParcialmente)
{
lstHistorico.Add("Plano de Trabalho avaliado parcialmente por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília.");
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Excluindo)
{
lstHistorico.Add("Plano de Trabalho excluido por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília.");
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Negando)
{
lstHistorico.Add("Solicitação de Plano de Trabalho negada por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília.");
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Suspendendo)
{
string textoReativacao = "";
if (pacto.SuspensoAte.HasValue)
{
textoReativacao = ", com reativação programada para dia " + pacto.SuspensoAte.Value.ToString("dd/MM/yyyy");
}
lstHistorico.Add("Pacto Plano de Trabalho por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília" + textoReativacao + "." + pacto.Motivo);
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.VoltandoSuspensao)
{
lstHistorico.Add("Término da suspensão por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília." + pacto.Motivo);
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Editando)
{
lstHistorico.Add("Plano de Trabalho alterado por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília." + pacto.Motivo);
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.CancelandoAvaliacao)
{
lstHistorico.Add("Avaliação de Plano de Trabalho cancelada por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília." + pacto.Motivo);
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.CancelandoAvaliacaoParcialmente)
{
lstHistorico.Add("Avaliação parcial de Plano de Trabalho cancelada por " + _usuarioService.ObterPorCPF(user.CpfUsuario).Nome + "," + strPerfil + ", na unidade " + _unidadeService.ObterUnidades().FirstOrDefault(x => x.IdUnidade == pacto.UnidadeExercicio).Nome + " em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília." + pacto.Motivo);
}
else if ((int)acao == (int)PGD.Domain.Enums.eAcaoPacto.Finalizando)
{
lstHistorico.Add("Situação do Plano de Trabalho alterada automaticamente pelo término do prazo de sua execução, em " + DateTime.Now.ToShortDateString() + ", às " + DateTime.Now.ToShortTimeString() + ", conforme horário oficial de Brasília.");
}
TratarHistoricoRestricaoVisualizacao(pacto, user, acao, lstHistorico, strPerfil);
AdicionarListaHistoricos(pacto, lstHistorico);
return(pacto);
}
public PactoViewModel AtualizarStatus(PactoViewModel pactoViewModel, UsuarioViewModel usuario, eAcaoPacto eAcao, bool commit = true)
{
BeginTransaction();
if (!usuario.IsDirigente && pactoViewModel.StatusAprovacaoDirigente != null)
{
pactoViewModel.CpfUsuarioSolicitante = usuario.CPF;
pactoViewModel.StatusAprovacaoSolicitante = 1;
pactoViewModel.DataAprovacaoSolicitante = DateTime.Now;
}
CriaHistoricoAcaoEmPacto(pactoViewModel, usuario.IsDirigente, usuario, eAcao);
var pacto = Mapper.Map <PactoViewModel, Pacto>(pactoViewModel);
var usr = Mapper.Map <UsuarioViewModel, Usuario>(usuario);
if (eAcao == eAcaoPacto.Avaliando)
{
if (pactoViewModel.DataTerminoReal != null)
{
pacto.DataTerminoReal = pactoViewModel.DataTerminoReal.Value;
}
pacto.EntregueNoPrazo = 1;
}
pacto = _pactoService.AtualizarStatus(pacto, usr, eAcao, usuario.IsDirigente, false);
if (pacto.ValidationResult.IsValid)
{
if (eAcao == eAcaoPacto.Assinando)
{
pacto.ValidationResult.Message = Mensagens.MS_006;
}
string oper = Domain.Enums.Operacao.Alteração.ToString();
switch (eAcao.ToString())
{
case "Suspendendo":
oper = Domain.Enums.Operacao.Suspensão.ToString();
break;
case "Interrompendo":
oper = Domain.Enums.Operacao.Interrupção.ToString();
break;
case "Avaliando":
oper = Domain.Enums.Operacao.Avaliacao.ToString();
break;
case "VoltandoSuspensao":
oper = Domain.Enums.Operacao.VoltandoSuspensão.ToString();
break;
}
_logService.Logar(pacto, usuario.CPF, oper);
List <ValidationError> lstErros = Commit();
if (lstErros?.Count > 0)
{
lstErros.ForEach(e =>
{
// LogManagerComum.LogarErro(null, null, " Erro ao salvar a ação. " + e.Message);
pacto.ValidationResult.Add(e);
});
pacto.ValidationResult.Message = Mensagens.MS_010;
}
}
pactoViewModel = Mapper.Map <Pacto, PactoViewModel>(pacto);
return(pactoViewModel);
}