public Evento_AdicionarConflito()
{
evento = MockRepository.GenerateStub<Evento>();
outroEvento = MockRepository.GenerateStub<Evento>();
evento.AdicionarConflito(outroEvento, MotivoConflitoEnum.ExisteEventoParoquialNaData);
}
public IEnumerable<Evento> QueReservaramOMesmoLocal(Evento evento)
{
var query = documentSession.Advanced.LuceneQuery<Evento>("ReservasMap");
query = query.OpenSubclause();
for (int i = 0; i < evento.Reservas.Count(); i++)
{
var reserva = evento.Reservas.ToList()[i];
query = query
.Not.WhereEquals("Id", evento.Id)
.WhereEquals("IdLocal", reserva.Local.Id)
.AndAlso().WhereEquals("Data", reserva.Data)
.AndAlso().OpenSubclause();
for (int j = 0; j < reserva.Hora.Count; j++)
{
query = query.WhereEquals("Hora", (int)reserva.Hora[j]);
if (j + 1 < reserva.Hora.Count)
query = query.OrElse();
}
query = query.CloseSubclause().CloseSubclause();
if (i + 1 < evento.Reservas.Count())
query = query.OrElse().OpenSubclause();
}
return query.ToList();
}
public ConflitoTest()
{
evento = MockRepository.GenerateStub<Evento>();
dataAtual = DateTime.Now;
SystemTime.Now = () => dataAtual;
conflito = new Conflito(evento, MotivoConflitoEnum.ExisteEventoParoquialNaData);
}
private void DesmarcaEventosNaoParoquiaisDaMesmaData(Evento novoEvento)
{
var eventosNaoParoquiaisEmConflito = eventos.Todos(Evento.MontarVerificacaoDeConflitoDeHorario(novoEvento.DataInicio, novoEvento.DataFim))
.Where(e => e.Tipo != TipoEventoEnum.Paroquial && e.Id != novoEvento.Id).ToList();
foreach (Evento eventoNaoParoquial in eventosNaoParoquiaisEmConflito)
{
eventoNaoParoquial.AdicionarConflito(novoEvento, MotivoConflitoEnum.ExisteEventoParoquialNaData);
}
}
private string ExtrairLocaisDasReservas(Evento evento)
{
StringBuilder locais = new StringBuilder();
foreach (var reserva in evento.Reservas)
{
var separador = (locais.Length > 0 ? ", " : "");
locais.Append(separador + reserva.Local.Nome);
}
return locais.ToString();
}
private Func<Evento, bool> CriarCondicaoParaVerificarReservaDeLocal(Evento novoEvento)
{
Expression<Func<Evento, bool>> predicate = PredicateBuilder.InitializeWithFalse<Evento>();
foreach (Reserva reserva in novoEvento.Reservas)
{
predicate = predicate.Or(e => e.Reservas.Count(r => r.PossuiConflitoCom(reserva)) > 0);
}
return predicate.Compile();
}
private void CriarEventoExistenteQueReservouLocal(TipoEventoEnum tipoEvento)
{
eventoExistente = CriarEvento(tipoEvento, dataAtual, dataAtual.AddHours(4));
localDesejado = new Local("Um Local");
dataReservaExistente = dataAtual;
eventoExistente.Reservar(localDesejado, dataReservaExistente, new List<HoraReservaEnum> { HoraReservaEnum.Tarde });
DataBaseSession.Store(eventoExistente);
DataBaseSession.SaveChanges();
}
private Evento CriarEventoComReserva()
{
dataInicioEvento = DateTime.Now;
dataFimEvento = dataInicioEvento.AddHours(4);
var grupo = MockRepository.GenerateStub<Grupo>();
var evento = new Evento("Nome", "Descricao", dataInicioEvento, dataFimEvento, grupo, TipoEventoEnum.Comum);
local = new Local("Local");
local.Id = "1";
evento.Reservar(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
return evento;
}
public Evento_Novo_Criado_Corretamente()
{
string nome = "Retiro Salvatoriano";
string descricao = "Retiro de aprofundamento da espiritualidade Salvatoriana";
dataInicioEvento = new DateTime(2011, 01, 01, 8, 0, 0);
dataFimEvento = new DateTime(2011, 01, 01, 10, 0, 0);
TipoEventoEnum tipoDoEvento = TipoEventoEnum.Comum;
Grupo grupo = MockRepository.GenerateStub<Grupo>();
grupo.Id = "IdGrupo";
dataAtual = DateTime.Now;
SystemTime.Now = () => dataAtual;
evento = new Evento(nome, descricao, dataInicioEvento, dataFimEvento, grupo, tipoDoEvento);
}
public void Agendar(Evento novoEvento)
{
var dataAberta = new DateTime(2013, 01, 01);
var dataAbertaParaAgendamento = Assertion.That(!String.IsNullOrEmpty(novoEvento.Id) || novoEvento.DataInicio > new DateTime(2013, 01, 01))
.WhenNot(String.Format("Só é permitido agendar eventos para datas posteriores a {0}", dataAberta.ToString("dd/MM/yyyy")));
dataAbertaParaAgendamento.Validate();
VerificaSeConflitaComEventoParoquial(novoEvento);
if (novoEvento.Tipo == TipoEventoEnum.Paroquial)
DesmarcaEventosNaoParoquiaisDaMesmaData(novoEvento);
VerificaDisponibilidadeDeLocais(novoEvento);
eventos.Salvar(novoEvento);
}
private void VerificaDisponibilidadeDeLocais(Evento novoEvento)
{
IEnumerable<Evento> eventosQueReservaramLocalNoMesmoHorario = eventos.QueReservaramOMesmoLocal(novoEvento);
IList<Evento> eventosPrioritarios = new List<Evento>();
foreach (Evento eventoQueReservouLocal in eventosQueReservaramLocalNoMesmoHorario)
{
if (eventoQueReservouLocal.PossuiPrioridadeSobre(novoEvento))
eventosPrioritarios.Add(eventoQueReservouLocal);
else
eventoQueReservouLocal.AdicionarConflito(novoEvento, MotivoConflitoEnum.LocalReservadoParaEventoDeMaiorPrioridade);
}
if (eventosPrioritarios.Count > 0)
throw new LocalReservadoException(eventosPrioritarios);
}
private static string ObterCor(Evento evento)
{
// TODO colocar cor
//if (evento.Estado == EstadoEventoEnum.NaoAgendado)
//{
// return "8";
//}
//if (evento.Tipo == TipoEventoEnum.Paroquial)
//{
// return "1";
//}
//else if (evento.Grupo.Id == "1")
//{
// return "0";
//}
//else if (evento.Grupo.Id == "2" || (evento.Grupo.GrupoPai != null && evento.Grupo.GrupoPai.Id == "2"))
//{
// return "2";
//}
//else if (evento.Grupo.Id == "16" || (evento.Grupo.GrupoPai != null && evento.Grupo.GrupoPai.Id == "16"))
//{
// return "3";
//}
//else if (evento.Grupo.Id == "28" || (evento.Grupo.GrupoPai != null && evento.Grupo.GrupoPai.Id == "28"))
//{
// return "4";
//}
//else if (evento.Grupo.Id == "32" || (evento.Grupo.GrupoPai != null && evento.Grupo.GrupoPai.Id == "32"))
//{
// return "5";
//}
//else if (evento.Grupo.Id == "39" || (evento.Grupo.GrupoPai != null && evento.Grupo.GrupoPai.Id == "39"))
//{
// return "6";
//}
//else if (evento.Grupo.Id == "49" || (evento.Grupo.GrupoPai != null && evento.Grupo.GrupoPai.Id == "49"))
//{
// return "7";
//}
return "0";
}
public bool PossuiConflitoDeHorarioCom(Evento outroEvento)
{
return Evento.MontarVerificacaoDeConflitoDeHorario(outroEvento.DataInicio, outroEvento.DataFim).Compile()(this);
}
private void VerificaSeConflitaComEventoParoquial(Evento novoEvento)
{
IEnumerable<Evento> eventosParoquiaisEmConflito = eventos.Todos(Evento.MontarVerificacaoDeConflitoDeHorario(novoEvento.DataInicio, novoEvento.DataFim))
.Where(e => e.Tipo == TipoEventoEnum.Paroquial && e.Id != novoEvento.Id).ToList();
if (eventosParoquiaisEmConflito.Count() > 0)
throw new EventoParoquialExistenteException(eventosParoquiaisEmConflito);
}
public HorarioDeEventoAlteradoEvent(Evento eventoAlterado)
{
this.EventoAlterado = eventoAlterado;
}
private static string ObterTextoLocais(Evento evento)
{
StringBuilder textoLocais = new StringBuilder();
string separador = "";
foreach (var reserva in evento.Reservas)
{
textoLocais.Append(separador + reserva.Local.Nome);
separador = ", ";
}
return textoLocais.ToString();
}
private static void ImportarPara(IDocumentStore store)
{
Stopwatch sp = Stopwatch.StartNew();
using (var agenda = new AgendaContainer())
{
Console.WriteLine("Começando...");
#region Locais
Console.WriteLine("Importando Locais...");
IEnumerable<Local> locais = agenda.Local.ToList();
Console.WriteLine("Carregar Locais demorou: {0:#,#} ms", sp.ElapsedMilliseconds);
var locaisRaven = new List<NovaVersaoParoquia.Local>();
using (IDocumentSession s = store.OpenSession())
{
foreach (Local l in locais)
{
var local = new NovaVersaoParoquia.Local(l.Nome);
s.Store(local);
locaisRaven.Add(local);
}
s.SaveChanges();
}
Console.WriteLine("Locais: " + locaisRaven.Count);
#endregion
#region Grupos
Console.WriteLine("Importando Grupos...");
IEnumerable<Grupo> grupos = agenda.Grupo.ToList();
Console.WriteLine("Carregar Grupos demorou: {0:#,#} ms", sp.ElapsedMilliseconds);
var gruposRaven = new List<NovaVersaoParoquia.Grupo>();
using (IDocumentSession s = store.OpenSession())
{
#region grupos
foreach (Grupo g in grupos)
{
var grupo = new NovaVersaoParoquia.Grupo(g.Nome, DeParaGrupoEmail(g.Id), null);
s.Store(grupo);
gruposRaven.Add(grupo);
}
#endregion
s.SaveChanges();
}
Console.WriteLine("Grupos: " + gruposRaven.Count);
#endregion
#region TiposEvento
Console.WriteLine("Inserindo Tipos...");
using (IDocumentSession s = store.OpenSession())
{
s.Store(new NovaVersaoAgenda.TipoEvento { Id = ((int)NovaVersaoAgenda.TipoEventoEnum.Paroquial).ToString(), Nome = "Paroquial" });
s.Store(new NovaVersaoAgenda.TipoEvento { Id = ((int)NovaVersaoAgenda.TipoEventoEnum.Sacramento).ToString(), Nome = "Sacramento" });
s.Store(new NovaVersaoAgenda.TipoEvento { Id = ((int)NovaVersaoAgenda.TipoEventoEnum.GrandeMovimentoDePessoas).ToString(), Nome = "Grande movimento de pessoas" });
s.Store(new NovaVersaoAgenda.TipoEvento { Id = ((int)NovaVersaoAgenda.TipoEventoEnum.Comum).ToString(), Nome = "Comum" });
s.SaveChanges();
}
#endregion
#region Eventos
Console.WriteLine("Importando Eventos...");
IEnumerable<Evento> eventos = agenda.Evento
.Include("Grupo")
.Include("ListaInternaConflitos")
.Include("ListaInternaReservasDeLocais")
.Where(e => e.DataInicio.Year >= 2012)
.OrderBy(e => e.DataInicio).ToList();
Console.WriteLine("Para carregar eventos, demorou: {0:#,#} ms", sp.ElapsedMilliseconds);
var eventosRaven = new List<NovaVersaoAgenda.Evento>();
using (IDocumentSession s = store.OpenSession())
{
foreach (Evento ev in eventos)
{
var grupo = gruposRaven.Where(g => g.Nome == ev.Grupo.Nome).Single();
string descricao = ev.Descricao;
if (descricao != null && descricao.Length > 150)
descricao = descricao.Substring(0, 150);
var evento = new NovaVersaoAgenda.Evento(
ev.Nome,
descricao,
ev.DataInicio,
ev.DataFim,
grupo,
DeParaTipoEvento(ev.Tipo));
s.Store(evento);
eventosRaven.Add(evento);
}
s.SaveChanges();
}
Console.WriteLine("Eventos: " + eventos.Count());
#endregion
}
}
public void RemoverConflitoCom(Evento outroEvento)
{
#region pré-condição
Assertion outroEventNaoEhNulo = Assertion.That(outroEvento != null).WhenNot("Não foi possível remover conflitos referentes ao evento. Referência nula.");
#endregion
outroEventNaoEhNulo.Validate();
IEnumerable<Conflito> conflitosReferentesAoEvento = this.Conflitos.Where(c => c.Evento.Equals(outroEvento));
if (conflitosReferentesAoEvento != null)
{
foreach (Conflito conflito in conflitosReferentesAoEvento)
{
IList<Conflito> ConflitosAux = this.Conflitos.ToList();
ConflitosAux.Remove(conflito);
this.Conflitos = ConflitosAux;
}
}
if (this.Conflitos.Count() == 0)
{
this.Estado = EstadoEventoEnum.Agendado;
// TODO: enviar e-mail avisando que o evento voltou a ficar agendado
}
}
private Evento MapearEvento(Evento evento, EventoModel input)
{
evento.Alterar(input.Nome, input.Descricao, input.DataInicio.GetValueOrDefault(), input.DataFim.GetValueOrDefault(), GrupoLogado, ((TipoEventoEnum)input.Tipo));
var reservas = new List<Reserva>();
foreach (var reserva in input.Reservas)
{
var local = RavenSession.ObterLocais().First(l => l.Id == reserva.LocalId);
reservas.Add(new Reserva(local, reserva.Data.GetValueOrDefault(), reserva.Hora));
}
evento.AlterarReservasDeLocais(reservas);
return evento;
}
public EventoCanceladoEvent(Evento eventoCancelado)
{
this.Evento = eventoCancelado;
}
public Conflito(Evento evento, MotivoConflitoEnum motivo)
{
this.Evento = evento;
this.Motivo = motivo;
this.Data = SystemTime.Now();
}
private Evento GerarEvento(EventoViewModel input)
{
Evento evento;
if (!string.IsNullOrEmpty(input.Id))
{
evento = RavenSession.Load<Evento>(input.Id);
evento.Alterar(input.Nome, input.Descricao, input.DataInicio.GetValueOrDefault(), input.DataFim.GetValueOrDefault(), GrupoLogado, ((TipoEventoEnum)input.Tipo));
var reservas = new List<Reserva>();
foreach (var reserva in input.Reservas)
{
var local = RavenSession.ObterLocais().First(l => l.Id == reserva.LocalId);
reservas.Add(new Reserva(local, reserva.Data.GetValueOrDefault(), reserva.Hora));
}
evento.AlterarReservasDeLocais(reservas);
}
else
{
evento = new Evento(
input.Nome,
input.Descricao,
input.DataInicio.GetValueOrDefault(),
input.DataFim.GetValueOrDefault(),
GrupoLogado,
((TipoEventoEnum)input.Tipo)
);
foreach (var reserva in input.Reservas)
{
var local = RavenSession.ObterLocais().First(l => l.Id == reserva.LocalId);
evento.Reservar(local, reserva.Data.GetValueOrDefault(), reserva.Hora);
}
}
return evento;
}
private Evento CriarEvento(EventoModel input)
{
Evento evento = new Evento(
input.Nome,
input.Descricao,
input.DataInicio.GetValueOrDefault(),
input.DataFim.GetValueOrDefault(),
GrupoLogado,
((TipoEventoEnum)input.Tipo)
);
foreach (var reserva in input.Reservas)
{
var local = RavenSession.ObterLocais().First(l => l.Id == reserva.LocalId);
evento.Reservar(local, reserva.Data.GetValueOrDefault(), reserva.Hora);
}
return evento;
}
public IEnumerable<Evento> QuePossuemConflitoCom(Evento evento, MotivoConflitoEnum motivo)
{
return documentSession.Query<Evento>().Where(e => e.Conflitos.Any(c => c.Evento.Id.Equals(evento.Id) && c.Motivo == motivo));
}
public void AdicionarConflito(Evento outroEvento, MotivoConflitoEnum motivo)
{
#region pré-condição
var outroEventoNaoEhNulo = Assertion.That(outroEvento != null).WhenNot("Erro ao tentar adicionar conflito com evento nulo.");
#endregion
outroEventoNaoEhNulo.Validate();
this.Estado = EstadoEventoEnum.NaoAgendado;
if (Conflitos == null)
Conflitos = new List<Conflito>();
int quantidadeDeConflitosAntes = Conflitos.Count();
var conflitosAux = Conflitos.ToList();
conflitosAux.Add(new Conflito(outroEvento, motivo));
Conflitos = conflitosAux;
#region pós-condição
var aumentouAQuantidadeDeConflitos = Assertion.That(quantidadeDeConflitosAntes + 1 == Conflitos.Count())
.WhenNot("Erro ao adicionar conflitos ao evento. Quantidade não foi incrementada.");
#endregion
aumentouAQuantidadeDeConflitos.Validate();
}
public IEnumerable<Evento> QuePossuemConflitosCom(Evento evento)
{
return documentSession.Query<Evento>().Where(e => e.Conflitos.Any(c => c.Evento.Id.Equals(evento.Id)));
}
public bool PossuiPrioridadeSobre(Evento outroEvento)
{
bool esteFoiCadastradoAntes = DateTime.Compare(this.DataCadastro, outroEvento.DataCadastro) == -1;
return this.Tipo.NivelDePrioridadeNaAgenda() > outroEvento.Tipo.NivelDePrioridadeNaAgenda()
|| (this.Tipo.NivelDePrioridadeNaAgenda() == outroEvento.Tipo.NivelDePrioridadeNaAgenda() && esteFoiCadastradoAntes);
}
public void Salvar(Evento evento)
{
documentSession.Store(evento);
}
private void CriarEventoParoquialPreExistente()
{
DateTime dataInicio = DateTime.Now;
DateTime dataFim = dataInicio.AddHours(4);
eventoParoquialExistente = CriarEvento(TipoEventoEnum.Paroquial, dataInicio, dataFim);
DataBaseSession.Store(eventoParoquialExistente);
DataBaseSession.SaveChanges();
}
public ReservaDeLocalAlteradaEvent(Evento evento)
{
this.Evento = evento;
}
