public List <IEvento> ProcesarEvento(string ruta, char separador)
{
List <IEvento> eventos = new List <IEvento>();
List <string> contenido = _lectorArchivo.LeerArchivo(ruta);
List <Contenedor> contenedores = _procesadorString.ProcesarString(contenido, separador);
foreach (Contenedor contenedor in contenedores)
{
IEvento evento = null;
switch (contenedor.Tipo)
{
case TipoEvento.Futuro:
evento = new EventoFuturo(contenedor.Nombre, contenedor.Duracion, contenedor.Escala);
break;
case TipoEvento.Pasado:
evento = new EventoPasado(contenedor.Nombre, contenedor.Duracion, contenedor.Escala);
break;
}
eventos.Add(evento);
}
return(eventos);
}
public static IAssertion ValidarEvento(this IEvento evento)
{
var identificador = Assertion.IsFalse(evento.Identificador.Equals(Guid.Empty), "O identificador do evento não foi informado.");
var dataExecucao = Assertion.IsFalse(evento.DataExecucaoEvento.Equals(default(DateTime)), "A data de execução do evento não foi informada.");
return(identificador.and(dataExecucao));
}
//En su constructor se instanciará e iniciará un nuevo Thread para el atributo "hilo" y se asociará a
//EventoTiempo el manejador ImprimirReloj de la interfaz IEvento.
public Item(Reloj r, IEvento imprimir)
{
//No se si esta bien????
hilo.Start();
// Asocio el EVENTO al manejador
this.EventoTiempo += imprimir.ImprimirReloj;
}
public void EstablecerProximoEvento(string nombreEvento)
{
// Establecer proximo arribo en la lista de eventos.
var proximoEvento = this.generadorEventos.ObtenerProximo(this.tasasDeEventosAleatorios[nombreEvento]);
IEvento evento = this.ListaDeEventos.FirstOrDefault(e => e.Key == nombreEvento).Value.Item2;
this.ListaDeEventos[nombreEvento] = new Tuple <decimal, IEvento>(this.Reloj + proximoEvento, evento);
}
//En su constructor se instanciará e iniciará un nuevo Thread para el atributo hilo y se asociará a
//EventoTiempo el manejador ImprimirReloj de la interfaz IEvento.
public Item(IEvento imprimir, Reloj r)
{
//Creamos un delegado indicándole el nombre del método que correrá, luego creamos una instancia de
//Thread indicandole el delegado que será ejecutado y por último damos inicio al proceso pero por
//medio del hilo. (en un subproceso).
this.reloj = r;
this.hilo = new Thread(EjecutarReloj);
this.EventoReloj += imprimir.ImprimirReloj;
this.hilo.Start();
}
public async Task <EventoCobertura> Fabricar(IEvento evento)
{
EventoCobertura eventoCobertura;
eventoCobertura = await _fabricarEventoCobertura.Com(evento);
Assertion.NotNull(eventoCobertura, $"Impossivel criar um evento para {evento.GetType()}");
return(eventoCobertura);
}
public async Task <EventoPremio> Fabricar(IEvento evento)
{
EventoPremio eventoPremio;
switch (evento)
{
case IParcelaEmitida emissao:
eventoPremio = await _fabricarEventoPremio.Com(emissao);
break;
case IParcelaApropriada apropriacao:
eventoPremio = await _fabricarEventoPremio.Com(apropriacao);
break;
case IParcelaDesapropriada desapropriacao:
eventoPremio = await _fabricarEventoPremio.Com(desapropriacao);
break;
case IParcelaAjustada ajuste:
eventoPremio = await _fabricarEventoPremio.Com(ajuste);
break;
case IAporteApropriado aporte:
eventoPremio = await _fabricarEventoPremio.Com(aporte);
break;
case IPortabilidadeApropriada portabilidade:
eventoPremio = await _fabricarEventoPremio.Com(portabilidade);
break;
default:
eventoPremio = null;
break;
}
Assertion.NotNull(eventoPremio, $"Impossivel criar um evento para {evento.GetType()}");
return(eventoPremio);
}
public async Task <EventoCobertura> Com(IEvento message)
{
switch (message)
{
case ICoberturaSaldada eventosaldada:
evento = new EventoSaldamento(message.Identificador, message.IdentificadorCorrelacao, message.IdentificadorNegocio, message.DataExecucaoEvento);
evento.ComHistorico(await RetornaHistoricoCoberturaPeloIdentificador(eventosaldada.IdentificadorExternoCobertura, eventosaldada.ValorBeneficio, eventosaldada.ValorCapitalSegurado, StatusCobertura.StatusCoberturaEnum.Saldamento));
await PreencherProvisaoes(eventosaldada.IdentificadorExternoCobertura, evento);
break;
default:
evento = null;
break;
}
return(evento);
}
public void IniciarSimulacion()
{
var cantidadEventosOcurridos = 0;
while (cantidadEventosOcurridos < 1000)
{
IEvento evento = this.RutinaDeTiempo();
evento.RutinaEvento(this);
//this.reporte.RegistrarEvento(this);
//Console.ReadKey();
cantidadEventosOcurridos++;
}
Console.ReadKey();
// Calcular medidas de rendimiento.
this.reporte.ObtenerMedidasDeRendimiento(this);
throw new InvalidOperationException("Condición de fin de sumulación cumplida.");
}
public EventController(IEvento eventoService)
{
_eventoService = eventoService;
}
public EventoController(IEvento repositorio, IMapper mapper)
{
_eventoRepository = repositorio;
_mapper = mapper;
}
public CompensacaoContext(IEvento evento) : base(evento) { }
protected override EventoOperacional CriarEvento(IEvento request)
{
return null;
}
protected abstract EventoOperacional CriarEvento(IEvento request);
protected override EventoOperacional CriarEvento(IEvento request)
{
return(new EventoPortabilidadePremio(request.Identificador, request.IdentificadorCorrelacao, request.IdentificadorNegocio, request.DataExecucaoEvento));
}
public void QuitarEventoDeConsideracion(string nombreEvento)
{
IEvento evento = this.ListaDeEventos.FirstOrDefault(e => e.Key == nombreEvento).Value.Item2;
this.ListaDeEventos[nombreEvento] = new Tuple <decimal, IEvento>(decimal.MaxValue, evento);
}
public ProvisaoContext(IEvento request)
{
Request = request;
Evento = CriarEvento(request);
}
public Relojes(int cantidad, IEvento referencia) : this()
{
this.cantidad = cantidad;
this.referencia = referencia;
}
public void SetEvento(IEvento listener)
{
this.delete = listener;
this.Update = listener;
}
public InclusaoVgContext(IEvento request) : base(request)
{
}
protected override EventoOperacional CriarEvento(IEvento request)
{
return(new EventoImplantacao(request.Identificador, request.IdentificadorCorrelacao, request.IdentificadorNegocio, request.DataExecucaoEvento));
}
public void EstablecerEventoArriboInmediato(string nombreEvento)
{
IEvento evento = this.ListaDeEventos.FirstOrDefault(e => e.Key == nombreEvento).Value.Item2;
this.ListaDeEventos[nombreEvento] = new Tuple <decimal, IEvento>(this.Reloj, evento);
}
