/// <summary>
/// Depois de construir o objeto
/// </summary>
public override void AfterConstruction()
{
base.AfterConstruction();
TxCc = TxCco = TxUltimoComentario = string.Empty;
_dicEmailsCc = new Dictionary <string, string>();
_dicEmailsCco = new Dictionary <string, string>();
// Usuário logado é o solicitante
Solicitante = UsuarioDAO.GetUsuarioLogado(Session);
// Data atual
DtConclusao = DtEmissao = DateUtil.ConsultarDataHoraAtual();
// Prazo para depois de 10 dias
DtPrazo = Calendario.AcrescimoDiasUteisData(Session, DateUtil.ConsultarDataHoraAtual(), 10);
// Situação inicial
Situacao = ConfiguracaoDocumentoSituacao.GetSituacaoInicial(
ConfiguracaoDocumento.GetConfiguracaoPorTipo(Session, CsTipoDocumento.SolicitacaoOrcamento));
Colaborador colaborador = Colaborador.GetColaboradorCurrent(Session, UsuarioDAO.GetUsuarioLogado(Session));
if (colaborador != null)
{
TipoSolicitacao = colaborador.ColaboradorUltimoFiltro.LastTipoSolicitacaoSEOT;
Cliente = colaborador.ColaboradorUltimoFiltro.LastEmpresaInstituicaoSEOT;
}
}
/// <summary>
/// Método responsável por carregar o total de horas realizadas até a data estipulada
/// </summary>
/// <param name="oidCronograma">oid de identificação do cronograma selecionado</param>
/// <returns>retorna o total de horas planejadas </returns>
public static Dictionary <DateTime, double> ConsultarTotalHorasRealizadasCronograma(Guid oidCronograma, DateTime dataInicio, DateTime dataFinal)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
var historicos = contexto.CronogramaTarefa
.Where(o => o.OidCronograma == oidCronograma && !o.CsExcluido && !o.Tarefa.CsExcluido)
.Join(contexto.TarefaHistoricoEstimativa, ct => ct.OidTarefa,
th => th.OidTarefa,
(c, t) => t)
.ToList();
var datas = historicos.Where(o => o.DtPlanejado.Date >= dataInicio.Date).Select(o => o.DtPlanejado.Date).Distinct().OrderBy(o => o).ToList();
Dictionary <DateTime, double> somatorios = new Dictionary <DateTime, double>();
foreach (var data in datas)
{
if (data.Date > DateUtil.ConsultarDataHoraAtual().Date)
{
break;
}
double soma = 0;
soma = historicos.Where(o => o.DtPlanejado.Date <= data.Date)
.OrderByDescending(o => o.DtPlanejado)
.ToLookup(o => o.OidTarefa)
.Select(o => o.FirstOrDefault())
.ToList()
.Sum(o => o.NbHoraRestante);
somatorios.Add(data, soma);
}
return(somatorios);
}
}
public void CriarTarefaQuandoLogSofrerAlteracaoPorOutroUsuarioTest()
{
//cria situação planejamento
SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1",
CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução,
CsPadraoSistema.Sim, true);
Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);
string responsaveis = colaborador1.NomeCompleto;
//iníco tarefa
DateTime dtInicio = new DateTime();
Colaborador colaborador2 = ColaboradorFactoryEntity.CriarColaborador(contexto, "gabriel.matos", true);
//cria tarefa
Tarefa tarefa = new Tarefa();
tarefa = TarefaBo.CriarTarefa((string)"Tarefa 01", situacaoPlanejamento, dtInicio, colaborador1.Usuario.UserName, (string)"Criar método", responsaveis, 3);
tarefa.TxDescricao = "Tarefa Alterada";
tarefa.DtAtualizadoEm = DateUtil.ConsultarDataHoraAtual();
tarefa.AtualizadoPor = colaborador2;
contexto.SaveChanges();
DateUtil.CurrentDateTime = (DateTime)tarefa.DtAtualizadoEm;
Assert.AreEqual("Tarefa Alterada", tarefa.TxDescricao);
Assert.AreEqual(DateUtil.CurrentDateTime, tarefa.DtAtualizadoEm);
Assert.AreEqual(colaborador2, tarefa.AtualizadoPor);
}
/// <summary>
/// Método responsável por editar uma tarefa
/// </summary>
/// <param name="contexto">Sessão corrente</param>
/// <param name="oidCronogramaTarefa">Oid (Guid) da tarefa a ser editada</param>
/// <param name="txDescricao">Descrição da tarefa alterada</param>
/// <param name="oidSituacaoPlanejamento">Oid (Guid) da tarefa editada</param>
/// <param name="dataInicio">Data de Inicio da tarefa editada</param>
/// <param name="login">Login do usuário que editou a tarefa</param>
/// <param name="txObservacao">Observação da tarefa editada</param>
/// <param name="responsaveis">array de responsáveis pela tarefa</param>
/// <param name="nbEstimativaInicial">Estimativa inicial da tarefa</param>
/// <param name="nbEstimativaRestante">Estimativa restante da tarefa</param>
/// <param name="nbRealizado">Horas realizadas da tarefa</param>
/// <param name="csLinhaBaseSalva">Boolean afirmando se a tarefa foi salva a linda de base</param>
/// <returns>Retorna uma Hash contendo dados de atualizado em, atualizado por e confirmação da edição</returns>
public static Hashtable EditarTarefa(string oidCronogramaTarefa, string txDescricao, string oidSituacaoPlanejamento,
string login, string txObservacao, string responsaveis,
Int16 nbEstimativaInicial, TimeSpan nbEstimativaRestante, TimeSpan nbRealizado, bool csLinhaBaseSalva, DateTime dataInicio)
{
if (oidCronogramaTarefa == null || txDescricao == null || oidSituacaoPlanejamento == null ||
login == null)
{
throw new ArgumentException("Os parâmetros OidCronogramaTarefa, TxDescricao, DataInício, SituacaoPlanejamento, login e TxObservação são obrigatórios.");
}
Hashtable dadosEdicaoTarefa = new Hashtable();
CronogramaTarefa cronogramaTarefa = CronogramaTarefaDao.ConsultarCronogramaTarefaPorOid(Guid.Parse(oidCronogramaTarefa), o => o.Tarefa.SituacaoPlanejamento, o => o.Tarefa.AtualizadoPor.Usuario.Person);
if (cronogramaTarefa == null)
{
dadosEdicaoTarefa.Add("EdicaoStatus", false);
return(dadosEdicaoTarefa);
}
Tarefa tarefaAntiga = cronogramaTarefa.Tarefa.Clone();
Colaborador colaborador = ColaboradorDAO.ConsultarColaborador(login, o => o.Usuario.Person);
SituacaoPlanejamento situacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPlanejamentoPorOid(Guid.Parse(oidSituacaoPlanejamento));
if (colaborador != null)
{
cronogramaTarefa.Tarefa.OidAtualizadoPor = colaborador.Oid;
cronogramaTarefa.Tarefa.AtualizadoPor = null;
}
if (situacaoPlanejamento != null)
{
cronogramaTarefa.Tarefa.OidSituacaoPlanejamento = situacaoPlanejamento.Oid;
cronogramaTarefa.Tarefa.SituacaoPlanejamento = null;
}
cronogramaTarefa.Tarefa.CsLinhaBaseSalva = csLinhaBaseSalva;
cronogramaTarefa.Tarefa.NbEstimativaInicial = nbEstimativaInicial;
cronogramaTarefa.Tarefa.EstimativaRealizadoHora = nbRealizado;
cronogramaTarefa.Tarefa.TxDescricao = txDescricao;
cronogramaTarefa.Tarefa.TxObservacao = txObservacao;
cronogramaTarefa.Tarefa.DtAtualizadoEm = DateTime.Now;
cronogramaTarefa.Tarefa.TxResponsaveis = responsaveis;
cronogramaTarefa.Tarefa.DtInicio = dataInicio;
EstimarHorasRestantesSugeridaPorTipoSituacaoPlanejamento(cronogramaTarefa.Tarefa, nbEstimativaRestante.Ticks, situacaoPlanejamento);
TarefaDao.SalvarTarefa(cronogramaTarefa.Tarefa);
TarefaHistoricoEstimativaBo.CriarHistorico(DateUtil.ConsultarDataHoraAtual(), cronogramaTarefa.Tarefa.Oid, cronogramaTarefa.Tarefa.NbEstimativaRestante);
TarefaLogAlteracaoBo.CriarLogTarefa(cronogramaTarefa.Tarefa, tarefaAntiga);
dadosEdicaoTarefa.Add("EdicaoStatus", true);
dadosEdicaoTarefa.Add("DtAtualizadoEm", cronogramaTarefa.Tarefa.DtAtualizadoEm);
dadosEdicaoTarefa.Add("TxAtualizadoPor", colaborador.NomeCompleto);
return(dadosEdicaoTarefa);
}
/// <summary>
/// Verifica se o ciclo está com status de Não Planejado, se estiver desabilita botão cancelar ciclo, senão habilita;
/// </summary>
/// <returns>true para habilitar e false para desabilitar</returns>
public bool RnCancelamentoSituacaoNaoIniciado()
{
if (!CsSituacaoCiclo.Equals(CsSituacaoCicloDomain.Cancelado) && !CsSituacaoCiclo.Equals(CsSituacaoCicloDomain.Concluido) &&
DateUtil.ConsultarDataHoraAtual().Date >= DtInicio.Date)
{
return(true);
}
return(false);
}
/// <summary>
/// Método responsável por criar o colaborador caso não exista.
/// É usado pelo AD
/// <param name="extensaoEmail">Extensao do email da empresa</param>
/// <param name="session">Sessão</param>
/// <param name="login">Login do usuário</param>
/// </summary>
public static Colaborador RnCriarColaborador(Session session, string login, string extensaoEmail)
{
if (session == null || String.IsNullOrEmpty(login) == true || String.IsNullOrEmpty(extensaoEmail) == true)
{
throw new Exception("Os parâmetros Sessão, Login e ExtensaoEmail não podem ser nulos.");
}
string firstName;
string lastName;
string fullName;
DateTime dtAdmissaoCriada;
Colaborador colaboradorPesq = Colaborador.GetColaboradorPorLogin(session, login);
if (colaboradorPesq == null)
{
if (login.Contains("."))
{
firstName = login.Split('.')[0];
lastName = login.Split('.')[1];
fullName = String.Format("{0} {1}", StrUtil.UpperCaseFirst(firstName), StrUtil.UpperCaseFirst(lastName));
}
else
{
firstName = login;
lastName = "";
fullName = String.Format("{0}", StrUtil.UpperCaseFirst(login));
}
Colaborador colaboradorCriado = new Colaborador(session);
dtAdmissaoCriada = DateUtil.ConsultarDataHoraAtual();
firstName = StrUtil.UpperCaseFirst(firstName);
lastName = StrUtil.UpperCaseFirst(lastName);
colaboradorCriado.Usuario.ChangePasswordOnFirstLogon = false;
colaboradorCriado.Usuario.FirstName = firstName;
colaboradorCriado.Usuario.LastName = lastName;
colaboradorCriado.DtAdmissao = dtAdmissaoCriada;
colaboradorCriado.Usuario.UserName = login;
colaboradorCriado.Usuario.Email = login + extensaoEmail;
Role roleDefault = GetRolePorNome(session, "Default");
colaboradorCriado.Usuario.Roles.Add(roleDefault);
colaboradorCriado.Save();
UsuarioDAO.CurrentUser = colaboradorCriado.Usuario;
return(colaboradorCriado);
}
UsuarioDAO.CurrentUser = colaboradorPesq.Usuario;
return(colaboradorPesq);
}
/// <summary>
/// Método responsável por efetuar o calculo da quantidade de horas em desvio do burndown
/// </summary>
/// <param name="dadosBurndown">lista de dados do burndown</param>
/// <returns>resultado do calculo de desvio</returns>
public static double CalcularDesvio(List <BurndownDadosDto> dadosBurndown)
{
var dataAtual = DateUtil.ConsultarDataHoraAtual();
var selecao = dadosBurndown.Where(o => o.Dia.Date <= dataAtual.Date).OrderByDescending(o => o.Dia);
var ultimoDiaPlanejado = selecao.FirstOrDefault(q => q.CsTipo == CsTipoBurndown.Planejado);
var ultimoDiaRealizado = selecao.FirstOrDefault(q => q.CsTipo == CsTipoBurndown.Realizado);
var totalUltimoPlanejado = ultimoDiaPlanejado != null?ultimoDiaPlanejado.QtdeHoras.GetValueOrDefault() : 0;
var totalUltimoRealizado = ultimoDiaRealizado != null?ultimoDiaRealizado.QtdeHoras.GetValueOrDefault() : 0;
return(totalUltimoPlanejado - totalUltimoRealizado);
}
/// <summary>
/// adiciona dados a um historico de solicitação de orçamento
/// </summary>
private void SalvarSolicitacaoOrcamentoHistorico()
{
SolicitacaoOrcamentoHistorico soh = new SolicitacaoOrcamentoHistorico(Session)
{
SolicitacaoOrcamento = this,
ResponsavelHistorico = Responsavel,
AtualizadoPor = Colaborador.GetColaboradorCurrent(Session),
Situacoes = Situacao,
Comentario = TxUltimoComentario,
DataHora = DateUtil.ConsultarDataHoraAtual()
};
soh.Save();
}
/// <summary>
/// Preenchimento do "Atualizado Por" e "Atualizado Por"
/// </summary>
private void RnPreencherAtualizadoPorPlanejadoPor()
{
if (IsLoading)
{
return;
}
if (Oid.Equals(new Guid()))
{
TxAtualizado = string.Empty;
TxPlanejado = string.Format("{0} - {1:dd/MM/yyyy HH:mm}", UsuarioDAO.GetUsuarioLogado(Session).UserName,
DateUtil.ConsultarDataHoraAtual());
}
else
{
TxAtualizado = string.Format("{0} - {1:dd/MM/yyyy HH:mm}", UsuarioDAO.GetUsuarioLogado(Session).UserName,
DateUtil.ConsultarDataHoraAtual());
}
}
/// <summary>
/// Método responsável por realizar os cálculos necessários para formar o gráfico de Burndown
/// </summary>
/// <returns>Lista contendo os dados calculados que formam o gráfico</returns>
public BurndownGraficoDto CalcularDadosGraficoBurndown(Guid oidCronograma)
{
List <BurndownDadosDto> dadosGrafico = new List <BurndownDadosDto>();
Cronograma cronograma = CronogramaDao.ConsultarCronogramaPorOid(oidCronograma, o => o.CronogramaTarefas);
var diasUteis = CalendarioBo.CalcularDiasUteis(cronograma.DtInicio, cronograma.DtFinal);
double totalHorasCronograma = TarefaHistoricoEstimativaDao.ConsultarTotalHorasPlanejadasCronograma(oidCronograma);
totalHorasCronograma = totalHorasCronograma.ToTimeSpan().TotalHours;
double cargaDiaria = DividirCargaHoraria(totalHorasCronograma, diasUteis.Count - 1);
double horasRestantes = totalHorasCronograma;
diasUteis.ForEach(data => dadosGrafico.Add(CriarDtoPlanejamentoGraficoBurndown(cargaDiaria, ref horasRestantes, data)));
var somatorios = TarefaHistoricoEstimativaDao.ConsultarTotalHorasRealizadasCronograma(oidCronograma, cronograma.DtInicio, cronograma.DtFinal);
if (somatorios.Count > 0)
{
diasUteis = diasUteis.Union(somatorios.Keys.Where(o => o.Date <= DateUtil.ConsultarDataHoraAtual().Date)).OrderBy(o => o).ToList();
var ultimaEstimativa = somatorios.LastOrDefault();
var dataUltimaEstimativa = ultimaEstimativa.Key.AddDays(1);
var somaUltimaEstimativa = ultimaEstimativa.Value;
while (dataUltimaEstimativa.Date <= cronograma.DtFinal && dataUltimaEstimativa.Date <= DateUtil.ConsultarDataHoraAtual().Date)
{
if (diasUteis.Any(o => o.Date.Equals(dataUltimaEstimativa) && o.Date <= DateUtil.ConsultarDataHoraAtual().Date))
{
somatorios.Add(dataUltimaEstimativa, somaUltimaEstimativa);
}
dataUltimaEstimativa = dataUltimaEstimativa.AddDays(1);
}
dadosGrafico.AddRange(CriarDtoRealizadoGraficoBurndown(somatorios));
}
double desvio = CalcularDesvio(dadosGrafico);
return(new BurndownGraficoDto {
DadosBurndown = dadosGrafico, Desvio = desvio
});
}
/// <summary>
/// Verifica se algum dos próximos ciclos estão em uma situação diferente a não planejado, se sim não mostra, senão não mostra
/// </summary>
/// <returns>true or false</returns>
public bool RnMostrarInicioProximoCiclo()
{
Projeto.Ciclos.Sorting.Add(new SortProperty("NbCiclo", SortingDirection.Ascending));
if (DateUtil.ConsultarDataHoraAtual().CompareTo(DtTermino) > 0 ||
Projeto.Ciclos.IndexOf(this) + 1 >= Projeto.Ciclos.Count)
{
return(false);
}
for (int i = Projeto.Ciclos.IndexOf(this) + 1; i < Projeto.Ciclos.Count; i++)
{
if (!Projeto.Ciclos[i].CsSituacaoCiclo.Equals(CsSituacaoCicloDomain.Cancelado) &&
!Projeto.Ciclos[i].CsSituacaoCiclo.Equals(CsSituacaoCicloDomain.Concluido))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Método responsável por criar uma tarefa. Obs: Ela pode ser independente de projeto ou não.
/// É usado pela classe CronogramaTarefa ou pode ser avulsa.
/// </summary>
/// <param name="txDescricaoTarefa">descrição da tarefa</param>
/// <param name="txObservacaoTarefa">observação da tarefa</param>
/// <param name="situacaoPlanejamento">situação da tarefaClone</param>
/// <param name="responsavel">responsáveis pela tarefaClone</param>
/// <param name="estimativaInicial">estimativa inicial para tarefa</param>
/// <param name="dtInicio">data de início da tarefa</param>
public static Tarefa CriarTarefa(string txDescricaoTarefa, SituacaoPlanejamento situacaoPlanejamento, DateTime dtInicio, string login, string txObservacaoTarefa = "", string responsaveis = null, Int16 estimativaInicial = 0)
{
if (txDescricaoTarefa == null ||
dtInicio == null ||
situacaoPlanejamento == null ||
login == null)
{
throw new ArgumentException("Os parâmetros txDescricao, dtInício, situacaoPlanejamento e login são obrigatórios.");
}
var novaTarefa = new Tarefa
{
TxDescricao = txDescricaoTarefa,
TxObservacao = String.Empty,
TxResponsaveis = responsaveis,
NbEstimativaInicial = estimativaInicial,
NbEstimativaRestante = estimativaInicial.ToTicks(),
DtInicio = dtInicio,
OidSituacaoPlanejamento = situacaoPlanejamento.Oid,
SituacaoPlanejamento = situacaoPlanejamento
};
Colaborador colaborador = ColaboradorDAO.ConsultarColaborador(login, o => o.Usuario.Person);
if (colaborador != null)
{
novaTarefa.OidAtualizadoPor = colaborador.Oid;
novaTarefa.AtualizadoPor = colaborador;
}
novaTarefa.DtAtualizadoEm = DateUtil.ConsultarDataHoraAtual();
TarefaDao.SalvarTarefa(novaTarefa);
TarefaHistoricoEstimativaBo.CriarHistorico(DateUtil.ConsultarDataHoraAtual(), novaTarefa.Oid, novaTarefa.NbEstimativaRestante);
TarefaLogAlteracaoBo.CriarLogTarefa(novaTarefa, null);
return(novaTarefa);
}
/// <summary>
/// Criação/recriação dos períodos aquisitivos
/// </summary>
public void CriarPeriodosAquisitivos()
{
if (DtAdmissao == DateTime.MinValue)
{
return;
}
// Períodos existentes
Hashtable periodosHash = new Hashtable();
foreach (ColaboradorPeriodoAquisitivo periodo in PeriodosAquisitivos)
{
string key = String.Format("{0:dd/MM/yyyy} - {1:dd/MM/yyyy}", periodo.DtInicio, periodo.DtTermino);
if (!periodosHash.ContainsKey(key))
{
periodosHash.Add(key, periodo);
}
}
// Afastamentos não-remunerados
Afastamentos.Filter = CriteriaOperator.Parse("TipoAfastamento.IsRemunerado = false");
// Ordenação decrescente dos Afastamentos não-remunerados
Afastamentos.Sorting.Add(new SortProperty("DtInicio", SortingDirection.Descending));
List <ColaboradorAfastamento> ausencias = new List <ColaboradorAfastamento>(Afastamentos);
// Retirada da ordenação
Afastamentos.Sorting.RemoveAt(Afastamentos.Sorting.Count - 1);
// Retirada do filtro
Afastamentos.Filter = null;
ColaboradorAfastamento ausencia = null;
DateTime dtTerminoPeriodo, dtInicioProximoPeriodo = DtAdmissao, dtNow = DateUtil.ConsultarDataHoraAtual();
// criação dos novos períodos aquisitivos
while (dtInicioProximoPeriodo.Date <= dtNow.Date)
{
string key = string.Empty;
dtTerminoPeriodo = dtInicioProximoPeriodo.Date.AddYears(1).AddDays(-1); // data de término do período
if (ausencia == null && ausencias.Count > 0)
{
ausencia = ausencias[ausencias.Count - 1];
}
// Se houver ausência para o período atual, calcula o mesmo com retirada da mesma
if (ausencia != null && ausencia.DtInicio.Date >= dtInicioProximoPeriodo.Date &&
ausencia.DtInicio.Date <= dtTerminoPeriodo.Date)
{
DateTime dtInicio, dtTermino, dtTerminoAusencia = DateTime.MinValue;
int qtdeAusencia = 0;
while (ausencia != null && ausencia.DtInicio.Date >= dtInicioProximoPeriodo.Date &&
ausencia.DtInicio.Date <= dtTerminoPeriodo.Date)
{
dtTerminoAusencia = ausencia.DtTermino;
qtdeAusencia += ausencia.DtTermino.Subtract(ausencia.DtInicio).Days + 1;
dtInicio = dtInicioProximoPeriodo.Date;
dtTermino = ausencia.DtInicio.Date.AddDays(-1);
if (dtTermino > dtInicio)
{
key = String.Format("{0:dd/MM/yyyy} - {1:dd/MM/yyyy}", dtInicio, dtTermino);
if (!periodosHash.ContainsKey(key))
{
new ColaboradorPeriodoAquisitivo(Session)
{
Colaborador = this,
DtInicio = dtInicio,
DtTermino = dtTermino,
NbFeriasPlanejadas = 0
}.Save();
}
else
{
periodosHash.Remove(key);
}
dtInicioProximoPeriodo = dtTermino.AddDays(1);
}
// Remoção do Afastamento
ausencias.Remove(ausencia);
if (ausencias.Count > 0)
{
ausencia = ausencias[ausencias.Count - 1];
dtInicioProximoPeriodo = dtTerminoAusencia.Date.AddDays(1);
}
else
{
ausencia = null;
}
}
// Término da ausência
dtInicio = dtTerminoAusencia.Date.AddDays(1);
dtTermino = dtTerminoPeriodo.AddYears(qtdeAusencia / 360).AddDays(qtdeAusencia % 360);
if (dtTermino > dtInicio)
{
key = String.Format("{0:dd/MM/yyyy} - {1:dd/MM/yyyy}", dtInicio, dtTermino);
if (!periodosHash.ContainsKey(key))
{
new ColaboradorPeriodoAquisitivo(Session)
{
Colaborador = this,
DtInicio = dtInicio,
DtTermino = dtTermino,
NbFeriasPlanejadas = 0
}.Save();
}
else
{
periodosHash.Remove(key);
}
dtInicioProximoPeriodo = dtTermino.AddDays(1);
}
}
// se não houver ausência, o término é 1 ano depois do início
else
{
key = String.Format("{0:dd/MM/yyyy} - {1:dd/MM/yyyy}", dtInicioProximoPeriodo, dtTerminoPeriodo);
if (!periodosHash.ContainsKey(key))
{
new ColaboradorPeriodoAquisitivo(Session)
{
Colaborador = this,
DtInicio = dtInicioProximoPeriodo.Date,
DtTermino = dtTerminoPeriodo,
NbFeriasPlanejadas = 0
}.Save();
}
else
{
periodosHash.Remove(key);
}
dtInicioProximoPeriodo = dtInicioProximoPeriodo.AddYears(1);
}
}
// Apagando os períodos que ficaram no lixo
foreach (DictionaryEntry periodoDic in periodosHash)
{
((ColaboradorPeriodoAquisitivo)periodoDic.Value).Delete();
}
}
/// <summary>
/// Criar Log para uma Tarefa específica
/// </summary>
/// <param name="tarefaAtual">Objeto de Tarefa</param>
/// <param name="tarefaAntiga">Objeto de Tarefa antes das alterações</param>
public static void CriarLogTarefa(Tarefa tarefaAtual, Tarefa tarefaAntiga)
{
if (tarefaAtual == null)
{
return;
}
string valorNovo, valorAntigo;
StringBuilder alteracoes = new StringBuilder();
if (tarefaAntiga == null)
{
alteracoes.Append("Criação da tarefa\n");
}
else
{
if (tarefaAtual.TxDescricao != tarefaAntiga.TxDescricao)
{
alteracoes.Append(String.Format("Descrição alterada de ' {0} ' para ' {1} '\n", tarefaAntiga.TxDescricao, tarefaAtual.TxDescricao));
}
if (tarefaAtual.SituacaoPlanejamento != tarefaAntiga.SituacaoPlanejamento)
{
valorNovo = tarefaAtual.SituacaoPlanejamento != null ? tarefaAtual.SituacaoPlanejamento.TxDescricao : string.Empty;
valorAntigo = tarefaAntiga.SituacaoPlanejamento != null ? tarefaAntiga.SituacaoPlanejamento.TxDescricao : string.Empty;
alteracoes.Append(String.Format("Situação alterada de ' {0} ' para ' {1} '\n", valorAntigo, valorNovo));
}
if (tarefaAtual.TxResponsaveis != tarefaAntiga.TxResponsaveis)
{
alteracoes.Append(String.Format("Responsável alterado de ' {0} ' para ' {1} '\n",
tarefaAntiga.TxResponsaveis, tarefaAtual.TxResponsaveis));
}
if (tarefaAtual.NbEstimativaRestante != tarefaAntiga.NbEstimativaRestante)
{
alteracoes.Append(String.Format("Estimativa Restante alterada de ' {0} ' para ' {1} '\n",
ConversorTimeSpan.ConverterTimeSpanParaString(tarefaAntiga.EstimativaRestanteHora),
ConversorTimeSpan.ConverterTimeSpanParaString(tarefaAtual.EstimativaRestanteHora)));
}
if (tarefaAtual.NbEstimativaInicial != tarefaAntiga.NbEstimativaInicial)
{
alteracoes.Append(String.Format("Estimativa Inicial alterada de ' {0} ' para ' {1} '\n",
ConversorTimeSpan.ConverterTimeSpanParaString(tarefaAntiga.EstimativaInicialHora),
ConversorTimeSpan.ConverterTimeSpanParaString(tarefaAtual.EstimativaInicialHora)));
}
if (tarefaAtual.NbRealizado != tarefaAntiga.NbRealizado)
{
alteracoes.Append(String.Format("Horas Realizadas alteradas de ' {0} ' para ' {1} '\n",
ConversorTimeSpan.ConverterTimeSpanParaString(tarefaAntiga.EstimativaRealizadoHora),
ConversorTimeSpan.ConverterTimeSpanParaString(tarefaAtual.EstimativaRealizadoHora)));
}
if (tarefaAtual.TxObservacao != tarefaAntiga.TxObservacao)
{
alteracoes.Append(String.Format("Observação alterada de ' {0} ' para ' {1} '\n",
tarefaAntiga.TxObservacao, tarefaAtual.TxObservacao));
}
if (((DateTime)tarefaAtual.DtInicio).Date != ((DateTime)tarefaAntiga.DtInicio).Date)
{
alteracoes.Append(String.Format("Data de Início alterada de ' {0:dd/MM/yyyy} ' para ' {1:dd/MM/yyyy} '\n",
tarefaAntiga.DtInicio, tarefaAtual.DtInicio));
}
}
if (alteracoes.Length > 0)
{
TarefaLogAlteracao logAlteracao = new TarefaLogAlteracao();
logAlteracao.OidTarefa = tarefaAtual.Oid;
logAlteracao.DtDataHoraLog = DateUtil.ConsultarDataHoraAtual();
logAlteracao.OidColaborador = tarefaAtual.OidAtualizadoPor;
logAlteracao.TxAlteracoes = alteracoes.ToString();
TarefaLogAlteracaoDao.Salvar(logAlteracao);
}
}
/// <summary>
/// Método chamado ao salvar
/// </summary>
protected override void OnSaving()
{
if (Oid.Equals(new Guid()))
{
TxUltimoComentario = "Criação do Documento";
}
// Código calculado
if (oldCliente != Cliente || string.IsNullOrEmpty(txCodigo))
{
TxCodigo = String.Format("{0}.{1}/{2}", Cliente.TxSigla, RnCriarNumeroSolicitacao(), DateUtil.ConsultarDataHoraAtual().Year);
SalvarSolicitacaoOrcamentoHistorico();
}
else
{
if (Situacao != oldSituacao || Oid.Equals(new Guid()) || !string.IsNullOrEmpty(TxUltimoComentario))
{
SalvarSolicitacaoOrcamentoHistorico();
}
}
//verificando dados da instituição
VerificarAlteracaoDadosEmpresaInstituicao();
Colaborador colaborador = Colaborador.GetColaboradorCurrent(Session, UsuarioDAO.GetUsuarioLogado(Session));
if (colaborador != null)
{
colaborador.ColaboradorUltimoFiltro.LastTipoSolicitacaoSEOT = TipoSolicitacao;
colaborador.ColaboradorUltimoFiltro.LastEmpresaInstituicaoSEOT = Cliente;
colaborador.Save();
}
base.OnSaving();
}
/// <summary>
/// Retorna uma descricao concatenada com o nome da classe
/// e a data e hora atual para ser utilizado nas factories
/// que possuem campos de descrição.
/// </summary>
/// <returns>Nova descricao</returns>
public static String GetDescricao()
{
return(String.Format("{0:yyyyMMddhhmmss}", DateUtil.ConsultarDataHoraAtual()));
}
/// <summary>
/// Util para sempre atribuir horario/dataHora atuais
/// </summary>
public override void AfterConstruction()
{
base.AfterConstruction();
DataHora = DateUtil.ConsultarDataHoraAtual();
}
/// <summary>
/// Método responsável por criar o colaborador caso não exista.
/// É usado pelo AD
/// <param name="extensaoEmail">Extensao do email da empresa</param>
/// <param name="contexto">Sessão</param>
/// <param name="login">Login do usuário</param>
/// </summary>
public static Colaborador CriarColaborador(string login, string extensaoEmail)
{
string primeiroNome;
string ultimoNome;
string nomeCompleto;
DateTime dtAdmissao;
Colaborador colaboradorPesquisado = ColaboradorDAO.ConsultarColaborador(login, o => o.Usuario);
if (colaboradorPesquisado != null)
{
return(colaboradorPesquisado);
}
if (login.Contains("."))
{
primeiroNome = StrUtil.UpperCaseFirst(login.Split('.')[0]);
ultimoNome = StrUtil.UpperCaseFirst(login.Split('.')[1]);
nomeCompleto = String.Format("{0} {1}", StrUtil.UpperCaseFirst(primeiroNome), StrUtil.UpperCaseFirst(ultimoNome));
}
else
{
primeiroNome = login;
ultimoNome = String.Empty;
nomeCompleto = String.Format("{0}", StrUtil.UpperCaseFirst(login));
}
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
ColaboradorUltimoFiltro colaboradorUltimoFiltro = ColaboradorUltimoFiltroBO.CriarColaboradorUltimoFiltroPadrao(contexto);
Party party = PartyBO.CriarPartyPadrao(contexto);
Person person = PersonBO.CriarPersonPadrao(contexto, party, primeiroNome, ultimoNome, login, extensaoEmail);
User usuario = UserBO.CriarUserPadrao(contexto, person, login);
dtAdmissao = DateUtil.ConsultarDataHoraAtual();
Colaborador novoColaborador = new Colaborador()
{
OidUsuario = usuario.Oid,
TxMatricula = null,
DtAdmissao = dtAdmissao,
OidCoordenador = null,
OidCargo = null,
OidColaboradorUltimoFiltro = colaboradorUltimoFiltro.Oid
};
contexto.Colaboradores.Add(novoColaborador);
contexto.SaveChanges();
Role roleDefault = ColaboradorDAO.ConsultarRolePorNome("Default");
Role roleAdmin = ColaboradorDAO.ConsultarRolePorNome("Administradores");
UserBO.CriarPermissaoParaUsuario(contexto, usuario, roleDefault);
UserBO.CriarPermissaoParaUsuario(contexto, usuario, roleAdmin);
ColaboradorPeriodoAquisitivoBO.CriarPeridoAquisitivoParaColaborador(contexto, novoColaborador, dtAdmissao);
return(novoColaborador);
}
}
/// <summary>
/// Método responsável por, atribuir um colaborador à tarefa, caso ele não esteja como responsável pela mesma,
/// atualizar a situação planejamento da tarefa e atualizar as estimativas da tarefa.
/// </summary>
/// <param name="oidTarefa">oid da tarefa</param>
/// <param name="colaborador">Objeto Colaborador</param>
/// <param name="situacaoPlanejamento">Objeto Situação Planejamento</param>
/// <param name="nbHoraRealizado">Hora realizado da atividade</param>
/// <param name="nbHoraRestante">Hora restante da atividade</param>
public static void AtualizarDadosTarefa(Guid oidTarefa, Colaborador colaborador, SituacaoPlanejamento situacaoPlanejamento, TimeSpan nbHoraRealizado, TimeSpan nbHoraRestante, bool CsLinhaBaseSalva)
{
if (oidTarefa == null || oidTarefa == new Guid())
{
throw new ArgumentException("O parâmetro oidTarefa é inválido");
}
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
Tarefa tarefa = TarefaDao.ConsultarTarefaPorOid(oidTarefa);
if (tarefa == null)
{
return;
}
//Atualiza a situação planejamento da tarefa e estimativas
if (situacaoPlanejamento != null && !tarefa.OidSituacaoPlanejamento.Equals(situacaoPlanejamento.Oid))
{
tarefa.SituacaoPlanejamento = null;
tarefa.OidSituacaoPlanejamento = situacaoPlanejamento.Oid;
}
if (colaborador != null && !tarefa.OidAtualizadoPor.Equals(colaborador.Oid))
{
tarefa.AtualizadoPor = null;
tarefa.OidAtualizadoPor = colaborador.Oid;
}
EstimarHorasRestantesSugeridaPorTipoSituacaoPlanejamento(tarefa, nbHoraRestante.Ticks, situacaoPlanejamento, true);
tarefa.EstimativaRealizadoHora += nbHoraRealizado;
tarefa.DtAtualizadoEm = DateUtil.ConsultarDataHoraAtual();
tarefa.CsLinhaBaseSalva = CsLinhaBaseSalva;
//Atualiza responsáveis tarefa
if (nbHoraRealizado.Ticks > 0)
{
if (!String.IsNullOrEmpty(tarefa.TxResponsaveis) || !String.IsNullOrWhiteSpace(tarefa.TxResponsaveis))
{
List <string> ResponsaveisTarefa = new List <string>(tarefa.TxResponsaveis.Split(','));
if (colaborador != null)
{
if (!ResponsaveisTarefa.Contains(colaborador.NomeCompleto))
{
tarefa.TxResponsaveis += "," + colaborador.NomeCompleto;
}
}
}
else
{
tarefa.TxResponsaveis += colaborador.NomeCompleto;
}
}
contexto.Tarefa.Attach(tarefa);
contexto.Entry(tarefa).State = EntityState.Modified;
contexto.SaveChanges();
TarefaHistoricoEstimativaBo.CriarHistorico(DateUtil.ConsultarDataHoraAtual(), tarefa.Oid, tarefa.NbEstimativaRestante);
}
}