private void InitParams(TipoCalendario tipo)
{
Tipo = tipo;
switch (Tipo)
{
case TipoCalendario.DATEPICKER_MONTH:
DataToggle = "datepicker";
MinViewMode = 1;
DateFormat = "MM/yyyy";
break;
case TipoCalendario.DATEPICKER_YEAR:
DataToggle = "datepicker";
MinViewMode = 2;
DateFormat = "yyyy";
break;
case TipoCalendario.DATERANGEPICKER_SINGLE:
DataToggle = "daterangepickersingle";
break;
default:
DataToggle = "daterangepicker";
break;
}
}
public void ExecutarMetodosAsync(TipoCalendarioDto dto, bool inclusao, TipoCalendario tipoCalendario)
{
servicoFeriadoCalendario.VerficaSeExisteFeriadosMoveisEInclui(dto.AnoLetivo);
if (inclusao)
{
servicoEvento.SalvarEventoFeriadosAoCadastrarTipoCalendario(tipoCalendario);
}
}
private async Task <bool> UeEmReaberturaDeFechamento(TipoCalendario tipoCalendario, string ueCodigo, string dreCodigo, int bimestre, DateTime dataReferencia)
{
var reaberturaPeriodo = await repositorioFechamentoReabertura.ObterReaberturaFechamentoBimestrePorDataReferencia(
bimestre,
dataReferencia,
tipoCalendario.Id,
dreCodigo,
ueCodigo);
return(reaberturaPeriodo != null);
}
private async Task <bool> UeEmFechamento(Turma turma, TipoCalendario tipoCalendario, string ueCodigo, string dreCodigo, int bimestre, DateTime dataReferencia)
{
if (turma.Ue == null)
{
turma.AdicionarUe(repositorioUe.ObterPorId(turma.UeId));
}
if (turma.Ue.Dre == null)
{
turma.Ue.AdicionarDre(repositorioDre.ObterPorId(turma.Ue.DreId));
}
return(await repositorioEventoFechamento.UeEmFechamento(dataReferencia, turma.Ue.Dre.CodigoDre, turma.Ue.CodigoUe, tipoCalendario.Id, bimestre));
}
private TipoCalendarioDto EntidadeParaDto(TipoCalendario entidade)
{
return(new TipoCalendarioDto()
{
Id = entidade.Id,
Nome = entidade.Nome,
AnoLetivo = entidade.AnoLetivo,
Modalidade = entidade.Modalidade,
DescricaoPeriodo = entidade.Periodo.GetAttribute <DisplayAttribute>().Name,
Periodo = entidade.Periodo,
Migrado = entidade.Migrado
});
}
public async Task ExecutarMetodosAsync(TipoCalendarioDto dto, bool inclusao, TipoCalendario tipoCalendario)
{
servicoFeriadoCalendario.VerficaSeExisteFeriadosMoveisEInclui(dto.AnoLetivo);
if (inclusao)
{
servicoEvento.SalvarEventoFeriadosAoCadastrarTipoCalendario(tipoCalendario);
var existeParametro = await mediator.Send(new VerificaSeExisteParametroSistemaPorAnoQuery(dto.AnoLetivo));
if (!existeParametro)
{
await mediator.Send(new ReplicarParametrosAnoAnteriorCommand(dto.AnoLetivo));
}
}
}
public TipoCalendario MapearParaDominio(TipoCalendarioDto dto)
{
TipoCalendario entidade = repositorio.ObterPorId(dto.Id);
if (entidade == null)
{
entidade = new TipoCalendario();
}
entidade.Nome = dto.Nome;
entidade.AnoLetivo = dto.AnoLetivo;
entidade.Periodo = dto.Periodo;
entidade.Situacao = dto.Situacao;
entidade.Modalidade = dto.Modalidade;
return(entidade);
}
public async Task SalvarEventoFeriadosAoCadastrarTipoCalendario(TipoCalendario tipoCalendario)
{
var feriados = await ObterEValidarFeriados();
var tipoEventoFeriado = ObterEValidarTipoEventoFeriado();
var eventos = feriados.Select(x => MapearEntidade(tipoCalendario, x, tipoEventoFeriado));
var feriadosErro = new List <long>();
await SalvarListaEventos(eventos, feriadosErro);
if (feriadosErro.Any())
{
TratarErros(feriadosErro);
}
}
public TipoCalendarioCompletoDto EntidadeParaDtoCompleto(TipoCalendario entidade)
{
return(new TipoCalendarioCompletoDto
{
Id = entidade.Id,
Nome = entidade.Nome,
AnoLetivo = entidade.AnoLetivo,
Periodo = entidade.Periodo,
Modalidade = entidade.Modalidade,
Situacao = entidade.Situacao,
AlteradoPor = entidade.AlteradoPor,
CriadoRF = entidade.CriadoRF,
AlteradoRF = entidade.AlteradoRF,
CriadoEm = entidade.CriadoEm,
CriadoPor = entidade.CriadoPor,
DescricaoPeriodo = entidade.Periodo.GetAttribute <DisplayAttribute>().Name,
});
}
private Evento MapearEntidade(TipoCalendario tipoCalendario, FeriadoCalendario x, Entidades.EventoTipo tipoEventoFeriado)
{
return(new Evento
{
FeriadoCalendario = x,
DataFim = new DateTime(tipoCalendario.AnoLetivo, x.DataFeriado.Month, x.DataFeriado.Day),
DataInicio = new DateTime(tipoCalendario.AnoLetivo, x.DataFeriado.Month, x.DataFeriado.Day),
Descricao = x.Nome,
Nome = x.Nome,
FeriadoId = x.Id,
Letivo = tipoEventoFeriado.Letivo,
TipoCalendario = tipoCalendario,
TipoCalendarioId = tipoCalendario.Id,
TipoEvento = tipoEventoFeriado,
TipoEventoId = tipoEventoFeriado.Id,
Excluido = false
});
}
public TipoCalendario MapearParaDominio(TipoCalendarioDto dto, long id)
{
TipoCalendario entidade = repositorio.ObterPorId(id);
bool possuiEventos = repositorioEvento.ExisteEventoPorTipoCalendarioId(id);
if (entidade == null)
{
entidade = new TipoCalendario();
}
entidade.Nome = dto.Nome;
entidade.Situacao = dto.Situacao;
if (!possuiEventos)
{
entidade.AnoLetivo = dto.AnoLetivo;
entidade.Periodo = dto.Periodo;
entidade.Modalidade = dto.Modalidade;
}
return(entidade);
}
private TipoCalendarioCompletoDto EntidadeParaDtoCompleto(TipoCalendario entidade)
{
bool possuiEventos = repositorioEvento.ExisteEventoPorTipoCalendarioId(entidade.Id);
return(new TipoCalendarioCompletoDto
{
Id = entidade.Id,
Nome = entidade.Nome,
AnoLetivo = entidade.AnoLetivo,
Periodo = entidade.Periodo,
Modalidade = entidade.Modalidade,
Situacao = entidade.Situacao,
AlteradoPor = entidade.AlteradoPor,
CriadoRF = entidade.CriadoRF,
AlteradoRF = entidade.AlteradoRF,
CriadoEm = entidade.CriadoEm,
CriadoPor = entidade.CriadoPor,
DescricaoPeriodo = entidade.Periodo.GetAttribute <DisplayAttribute>().Name,
PossuiEventos = possuiEventos
});
}
public static DateTime SumarDiasSegunTipoCalendario(DateTime fecha, int dias, TipoCalendario tipo_cal = TipoCalendario.SinDiasHabiles)
{
if (fecha == null)
{
throw new ArgumentNullException("Fecha para sumar no puede ser nula");
}
int dato = 0;
if (tipo_cal == TipoCalendario.DiasHabiles)
{
int año_fec = fecha.Year;
int mes_fec = fecha.Month;
int dia_fec = fecha.Day;
int dias_febrero = 28;
if (año_fec % 4 == 0)
{
dias_febrero = 29;
}
if (dia_fec > 30 || (mes_fec == 2 && dia_fec >= dias_febrero))
{
dia_fec = 30;
}
dato = (dias / 360);
if (dato > 1)
{
año_fec = año_fec + dato;
dias = dias - (360 * dato);
}
dato = (dias / 30);
if (dato >= 1)
{
mes_fec = mes_fec + dato;
if (mes_fec > 12)
{
if (mes_fec > 12)
{
while (mes_fec > 12)
{
año_fec = año_fec + 1;
mes_fec = mes_fec - 12;
}
}
}
dias = dias - (30 * dato);
}
if (dias > 0)
{
if (30 - dia_fec < dias)
{
mes_fec = mes_fec + 1;
if (mes_fec > 12)
{
año_fec = año_fec + 1;
mes_fec = 1;
}
dia_fec = dias - (30 - dia_fec);
}
else
{
dia_fec = dia_fec + dias;
}
}
if (mes_fec == 2 && (dia_fec > dias_febrero && dia_fec <= 30))
{
dia_fec = dias_febrero;
}
if (mes_fec == 2 && (dia_fec > 30 && dia_fec <= 59))
{
dia_fec = dia_fec - (30 - dias_febrero);
}
if (mes_fec == 4 || mes_fec == 6 || mes_fec == 9 || mes_fec == 11)
{
if (dia_fec == 31)
{
dia_fec = 30;
}
}
// Validar mes de febrero
if (año_fec % 4 == 0)
{
dias_febrero = 29;
}
else
{
dias_febrero = 28;
}
if (mes_fec == 2 && (dia_fec > dias_febrero && dia_fec <= 30))
{
dia_fec = dias_febrero;
}
// Crear la fecha
fecha = new DateTime(año_fec, mes_fec, dia_fec, 0, 0, 0);
}
else
{
fecha = fecha.AddDays(dias);
}
return(fecha);
}
public async Task DeveCriarEventoEValidarParticularidadesSME_LiberacaoExcepcional_Periodo_Alertar()
{
//ARRANGE
var tipoEvento = new EventoTipo
{
Id = 1,
Codigo = (int)TipoEvento.LiberacaoExcepcional,
TipoData = EventoTipoData.InicioFim,
LocalOcorrencia = EventoLocalOcorrencia.UE
};
repositorioEventoTipo.Setup(c => c.ObterPorId(It.IsAny <long>()))
.Returns(tipoEvento);
var tipoCalendario = new TipoCalendario
{
Id = 1
};
repositorioTipoCalendario.Setup(c => c.ObterPorId(It.IsAny <long>()))
.Returns(tipoCalendario);
var listaPeriodoEscolar = new List <PeriodoEscolar>()
{
new PeriodoEscolar()
{
PeriodoInicio = DateTime.Today, PeriodoFim = DateTime.Today.AddDays(7)
}
};
repositorioPeriodoEscolar.Setup(a => a.ObterPorTipoCalendario(tipoCalendario.Id)).Returns(listaPeriodoEscolar);
var usuario = new Usuario();
var perfil = new PrioridadePerfil
{
CodigoPerfil = Guid.Parse("23A1E074-37D6-E911-ABD6-F81654FE895D"),
Tipo = TipoPerfil.DRE
};
usuario.DefinirPerfis(new List <PrioridadePerfil>
{
perfil
});
servicoUsuario.Setup(c => c.ObterUsuarioLogado())
.Returns(Task.FromResult(usuario));
var evento = new Evento
{
TipoCalendarioId = tipoCalendario.Id,
DreId = "1",
UeId = "2",
TipoEvento = tipoEvento,
DataInicio = DateTime.Now.AddMonths(1),
DataFim = DateTime.Now.AddMonths(1).AddDays(2),
Letivo = EventoLetivo.Sim
};
//ASSERT
await Assert.ThrowsAsync <NegocioException>(() => servicoEvento.Salvar(evento));
}
public async Task DeveCriarEventoEValidarParticularidadesSME_LiberacaoExcepcional(TipoPerfil tipoPerfil, bool sucesso)
{
//ARRANGE
var tipoEvento = new EventoTipo
{
Id = 1,
Codigo = (int)TipoEvento.LiberacaoExcepcional,
TipoData = EventoTipoData.InicioFim,
LocalOcorrencia = EventoLocalOcorrencia.UE
};
repositorioEventoTipo.Setup(c => c.ObterPorId(It.IsAny <long>()))
.Returns(tipoEvento);
var tipoCalendario = new TipoCalendario
{
Id = 1
};
repositorioTipoCalendario.Setup(c => c.ObterPorId(It.IsAny <long>()))
.Returns(tipoCalendario);
var listaPeriodoEscolar = new List <PeriodoEscolar>()
{
new PeriodoEscolar()
{
PeriodoInicio = DateTime.Today, PeriodoFim = DateTime.Today.AddDays(7)
}
};
repositorioPeriodoEscolar.Setup(a => a.ObterPorTipoCalendario(tipoCalendario.Id)).Returns(listaPeriodoEscolar);
var usuario = new Usuario();
var perfil = new PrioridadePerfil
{
CodigoPerfil = Guid.Parse("23A1E074-37D6-E911-ABD6-F81654FE895D"),
Tipo = tipoPerfil
};
usuario.DefinirPerfis(new List <PrioridadePerfil>
{
perfil
});
servicoUsuario.Setup(c => c.ObterUsuarioLogado())
.Returns(Task.FromResult(usuario));
var evento = new Evento
{
TipoCalendarioId = tipoCalendario.Id,
DreId = "1",
UeId = "2",
TipoEvento = tipoEvento,
DataInicio = DateTime.Now,
DataFim = DateTime.Now.AddDays(2),
Letivo = EventoLetivo.Sim
};
var ue = new AbrangenciaUeRetorno();
repositorioAbrangencia.Setup(a => a.ObterUe(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>())).Returns(Task.FromResult(ue));
//ASSERT
try
{
await servicoEvento.Salvar(evento, true);
Assert.True(true);
}
catch (Exception)
{
if (sucesso)
{
Assert.True(false);
}
}
}
public CalendarControl(TipoCalendario tipo = TipoCalendario.DATERANGEPICKER)
{
InitParams(tipo);
}
public async Task <bool> TurmaEmPeriodoAberto(Turma turma, DateTime dataReferencia, int bimestre = 0, bool ehAnoLetivo = false, TipoCalendario tipoCalendario = null)
{
if (tipoCalendario == null)
{
tipoCalendario = await consultasTipoCalendario.ObterPorTurma(turma);
if (tipoCalendario == null)
{
throw new NegocioException($"Tipo de calendário para turma {turma.CodigoTurma} não localizado!");
}
}
var periodoEmAberto = await consultasTipoCalendario.PeriodoEmAberto(tipoCalendario, dataReferencia, bimestre, ehAnoLetivo);
return(periodoEmAberto || await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma, tipoCalendario, dataReferencia, bimestre));
}
public async Task <bool> TurmaEmPeriodoAberto(long turmaId, DateTime dataReferencia, int bimestre = 0, TipoCalendario tipoCalendario = null)
{
var turma = await ObterComUeDrePorId(turmaId);
if (turma == null)
{
throw new NegocioException($"Turma de ID {turmaId} não localizada!");
}
return(await TurmaEmPeriodoAberto(turma, dataReferencia, bimestre, tipoCalendario : tipoCalendario));
}
public async Task <bool> TurmaEmPeriodoAberto(string codigoTurma, DateTime dataReferencia, int bimestre = 0, TipoCalendario tipoCalendario = null)
{
var turma = await ObterComUeDrePorCodigo(codigoTurma);
if (turma == null)
{
throw new NegocioException($"Turma de código {codigoTurma} não localizada!");
}
return(await TurmaEmPeriodoAberto(turma, dataReferencia, bimestre, tipoCalendario : tipoCalendario));
}
private async Task <IEnumerable <Ue> > ObterUesEvento(string dreCodigo, string ueCodigo, TipoCalendario tipoCalendario)
{
if (!string.IsNullOrEmpty(ueCodigo))
{
return new List <Ue>()
{
await mediator.Send(new ObterUeComDrePorCodigoQuery(ueCodigo))
}
}
;
if (!string.IsNullOrEmpty(dreCodigo))
{
return(await mediator.Send(new ObterUesComDrePorCodigoEModalidadeQuery(dreCodigo, tipoCalendario.ObterModalidadeTurma())));
}
return(await mediator.Send(new ObterUEsPorModalidadeCalendarioQuery(tipoCalendario.Modalidade)));
}
}
public async Task <bool> PeriodoEmAberto(TipoCalendario tipoCalendario, DateTime dataReferencia, int bimestre = 0, bool ehAnoLetivo = false) => await repositorio.PeriodoEmAberto(tipoCalendario.Id, dataReferencia, bimestre, ehAnoLetivo);
private void Setup()
{
aula = new Aula()
{
DisciplinaId = "1",
UeId = "1",
DataAula = new DateTime(2019, 12, 2),
TurmaId = "1",
Quantidade = 1,
RecorrenciaAula = RecorrenciaAula.AulaUnica
};
IEnumerable <Aula> aulasRecorrentes = new List <Aula>()
{
new Aula()
{
Id = 2, DataAula = DateTime.Parse("2019-12-09"), UeId = "1", TurmaId = "1", Quantidade = 1, DisciplinaId = "1", RecorrenciaAula = RecorrenciaAula.AulaUnica
},
new Aula()
{
Id = 2, DataAula = DateTime.Parse("2019-12-16"), UeId = "1", TurmaId = "1", Quantidade = 1, DisciplinaId = "1", RecorrenciaAula = RecorrenciaAula.AulaUnica
},
};
repositorioAula.Setup(a => a.UsuarioPodeCriarAulaNaUeTurmaEModalidade(It.IsAny <Aula>(), It.IsAny <ModalidadeTipoCalendario>())).Returns(true);
repositorioAula.Setup(a => a.ObterAulasRecorrencia(It.IsAny <long>(), It.IsAny <long?>(), It.IsAny <DateTime?>())).Returns(Task.FromResult(aulasRecorrentes));
usuario = new Usuario();
usuario.DefinirPerfis(new List <PrioridadePerfil>()
{
new PrioridadePerfil()
{
CodigoPerfil = Guid.Parse("40E1E074-37D6-E911-ABD6-F81654FE895D")
}
});
var tipoCalendario = new TipoCalendario();
IEnumerable <DisciplinaResposta> disciplinaRespotas = new List <DisciplinaResposta>()
{
new DisciplinaResposta()
{
CodigoComponenteCurricular = 1
}
};
repositorioTipoCalendario.Setup(a => a.ObterPorId(It.IsAny <long>())).Returns(tipoCalendario);
servicoEol.Setup(a => a.ObterDisciplinasPorCodigoTurmaLoginEPerfil(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>())).Returns(Task.FromResult(disciplinaRespotas));
//repositorioPeriodoEscolar.Setup(a => a.ObterPorTipoCalendarioData(aula.TipoCalendarioId, aula.DataAula)).Returns(new PeriodoEscolar());
consultasGrade.Setup(a => a.ObterGradeAulasTurmaProfessor(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <DateTime>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new GradeComponenteTurmaAulasDto()
{
QuantidadeAulasGrade = 1, QuantidadeAulasRestante = 1
}));
servicoDiaLetivo.Setup(a => a.ValidarSeEhDiaLetivo(It.IsAny <DateTime>(), It.IsAny <long>(), It.IsAny <string>(), It.IsAny <string>())).Returns(true);
///////
var periodoEscolar = new PeriodoEscolar()
{
PeriodoInicio = new DateTime(2019, 1, 1), PeriodoFim = new DateTime(2019, 1, 31)
};
//repositorioPeriodoEscolar.Setup(a => a.ObterPorTipoCalendarioData(aula.TipoCalendarioId, aula.DataAula)).Returns(periodoEscolar);
//repositorioPeriodoEscolar.Setup(a => a.ObterPorTipoCalendario(aula.TipoCalendarioId)).Returns(new List<PeriodoEscolar>() { periodoEscolar });
repositorioAbrangencia.Setup(a => a.ObterAbrangenciaTurma(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new AbrangenciaFiltroRetorno()
{
NomeDre = "Dre 1", NomeUe = "Ue 1", NomeTurma = "Turma 1A"
}));
consultasFrequencia.Setup(a => a.FrequenciaAulaRegistrada(It.IsAny <long>()))
.Returns(Task.FromResult(false));
}
public async Task <bool> TurmaEmPeriodoDeFechamento(Turma turma, TipoCalendario tipoCalendario, DateTime dataReferencia, int bimestre = 0)
{
var ueEmFechamento = await UeEmFechamento(turma, tipoCalendario, turma.Ue.CodigoUe, turma.Ue.Dre.CodigoDre, bimestre, dataReferencia);
return(ueEmFechamento || await UeEmReaberturaDeFechamento(tipoCalendario, turma.Ue.CodigoUe, turma.Ue.Dre.CodigoDre, bimestre, dataReferencia));
}
public async Task <string> Salvar(Evento evento, bool alterarRecorrenciaCompleta = false, bool dataConfirmada = false, bool unitOfWorkJaEmUso = false)
{
ObterTipoEvento(evento);
TipoCalendario tipoCalendario = ObterTipoCalendario(evento);
evento.ValidaPeriodoEvento();
var usuario = await servicoUsuario.ObterUsuarioLogado();
bool ehAlteracao = true;
if (evento.Id == 0)
{
ehAlteracao = false;
evento.TipoPerfilCadastro = usuario.ObterTipoPerfilAtual();
}
else
{
var entidadeNaoModificada = repositorioEvento.ObterPorId(evento.Id);
ObterTipoEvento(entidadeNaoModificada);
usuario.PodeAlterarEvento(entidadeNaoModificada);
}
usuario.PodeCriarEvento(evento);
var periodos = repositorioPeriodoEscolar.ObterPorTipoCalendario(evento.TipoCalendarioId);
if (evento.DeveSerEmDiaLetivo())
{
evento.EstaNoPeriodoLetivo(periodos);
}
bool devePassarPorWorkflowLiberacaoExcepcional = await ValidaDatasETiposDeEventos(evento, dataConfirmada, usuario, periodos);
AtribuirNullSeVazio(evento);
if (!unitOfWorkJaEmUso)
{
unitOfWork.IniciarTransacao();
}
repositorioEvento.Salvar(evento);
// Envia para workflow apenas na Inclusão ou alteração apos aprovado
var enviarParaWorkflow = !string.IsNullOrWhiteSpace(evento.UeId) && devePassarPorWorkflowLiberacaoExcepcional;
if (!ehAlteracao || (evento.Status == EntidadeStatus.Aprovado))
{
if (enviarParaWorkflow)
{
await PersistirWorkflowEvento(evento, devePassarPorWorkflowLiberacaoExcepcional);
}
}
if (!unitOfWorkJaEmUso)
{
unitOfWork.PersistirTransacao();
}
if (evento.EventoPaiId.HasValue && evento.EventoPaiId > 0 && alterarRecorrenciaCompleta)
{
SME.Background.Core.Cliente.Executar(() => AlterarRecorrenciaEventos(evento, alterarRecorrenciaCompleta));
}
if (ehAlteracao)
{
if (enviarParaWorkflow)
{
return("Evento alterado e será válido após aprovação.");
}
else
{
return("Evento alterado com sucesso.");
}
}
else
{
if (enviarParaWorkflow)
{
return("Evento cadastrado e será válido após aprovação.");
}
else
{
return("Evento cadastrado com sucesso.");
}
}
}
