/// <summary>
/// Metodo que emula el ciclo de vida de un paquete,
/// cambiando this.Estado estado secuencialmente segun indica el enumerado EEstado,
/// cada 10 segundos. Invocando al evento InformaEstado en cada paso, y guardando
/// el paquete en la base de datos al llegar al último elemento del enumerado,
/// utilizando la clase PaqueteDAO
/// </summary>
public void MockCicloDeVida()
{
do
{
InformaEstado.Invoke(this, null);
System.Threading.Thread.Sleep(10000);
//Recorre los distintos tipos de estado hasta el ultimo
this.Estado++;
} while (this.Estado != EEstado.Entregado);
//Inserta en base de datos
try
{
PaqueteDAO.Insertar(this);
}
//Si hay excepcion, invoca el evento ErrorBaseDeDatos con un diccionario <paquete, excepcion>
catch (Exception dbException)
{
Dictionary <Paquete, Exception> exceptionPaquete = new Dictionary <Paquete, Exception>()
{
{ this, dbException }
};
ErrorBaseDeDatos.Invoke(exceptionPaquete, null);
}
InformaEstado.Invoke(this, null);
}
/// <summary>
/// Cambia el estado del paquete cada hasta que este sea entregado y lo guarda en la base de datos.
/// </summary>
public void MockCicloDeVida()
{
do
{
if (this.estado == EEstado.Ingresado)
{
Thread.Sleep(4000);
this.estado = EEstado.EnViaje;
}
else if (this.estado == EEstado.EnViaje)
{
Thread.Sleep(4000);
this.estado = EEstado.Entregado;
}
this.InfornmarEstado.Invoke(this, EventArgs.Empty);
} while (this.estado != EEstado.Entregado);
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception)
{
throw new Exception("Error! Al momento de guardar en la base de datos");
}
}
/// <summary>
/// Hace que el paquete cambie de forma
/// </summary>
public void MockCicloDeVida()
{
do
{
Thread.Sleep(4000);
if (this.estado == EEstado.Ingresado)
{
this.estado = EEstado.EnViaje;
}
else if (this.estado == EEstado.EnViaje)
{
this.estado = EEstado.Entregado;
}
this.InformaEstado(this.estado, EventArgs.Empty);
} while (this.estado != EEstado.Entregado);
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// MockCicloDeVida hará que el paquete cambie de estado de la siguiente forma:
//a.Colocar una demora de 4 segundos.
//b.Pasar al siguiente estado.
//c.Informar el estado a través de InformarEstado. EventArgs no tendrá ningún dato extra.
//d.Repetir las acciones desde el punto A hasta que el estado sea Entregado.
//e.Finalmente guardar los datos del paquete en la base de datos
/// </summary
public void MockCicloDeVida()
{
do
{
Thread.Sleep(4000); //a
if (this.estado == EEstado.Ingresado) //b
{
this.estado = EEstado.EnViaje;
}
else if (this.estado == EEstado.EnViaje)
{
this.estado = EEstado.Entregado;
}
this.InformaEstado(this.estado, new EventArgs()); //c
} while (this.estado != EEstado.Entregado); //d
try
{
PaqueteDAO.Insertar(this); //e
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Simula el ciclo de vida de un paquete, cambiado su estado desde el inicio del viaje hasta entregado,
/// lanzando un evento ante cada cambio e insertandolo en la base de datos al finalizar.
/// </summary>
public void MockCicloDeVida()
{
while (this.estado != EEstado.Entregado)
{
Thread.Sleep(4000);
switch (this.estado)
{
case EEstado.Ingresado:
this.estado = EEstado.EnViaje;
break;
case EEstado.EnViaje:
this.estado = EEstado.Entregado;
break;
}
this.InformaEstado.Invoke(this.estado, EventArgs.Empty);
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception ex)
{
throw new Exception("Error al Insertar", ex);
}
}
/// <summary>
/// Repito el ciclo y lo corto -> Estado=entregado
/// </summary>
public void MockClicloDeVida()
{
while (true)
{
InformaEstado.Invoke(this, EventArgs.Empty);
Thread.Sleep(10000);
if (this.Estado == EEstado.Entregado)
{
break;
}
this.Estado++;
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Hace que el paquete cambie de estado y llama a funcion que agrega sus datos en la base de datos
/// </summary>
public void MockCicloDeVida()
{
while (this.estado != EEstado.Entregado)
{
Thread.Sleep(4000);
switch (this.estado)
{
case EEstado.Ingresado:
{
this.estado = EEstado.EnViaje;
}
break;
case EEstado.EnViaje:
{
this.estado = EEstado.Entregado;
}
break;
}
this.InformaEstado(this, new EventArgs());
}
PaqueteDAO.Insertar(this);
}
/// <summary>
/// Getiona el ciclo de vida del paquete, cambiando su estado,
/// informándolo y guardándolo en la base datos al pasar a entregado.
/// </summary>
public void mockCicloDeVida()
{
try
{
while (this.Estado != EEstado.Entregado)
{
this.InformaEstado.Invoke(this, null);
Thread.Sleep(4000);
if (this.Estado == EEstado.Ingresado)
{
this.Estado = EEstado.EnViaje;
}
else
{
this.Estado = EEstado.Entregado;
}
}
this.InformaEstado.Invoke(this, null);
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
//throw new Exception(e.Message, e);
/*No logré hacer llegar la excepción capturada
* al hilo principal*/
}
}
public void MockCicloDeVida()
{
Thread.Sleep(10000);
if (this.Estado == EEstado.Entregado)
{
this.Estado = EEstado.Entregado;
InformaEstado(this.estado, EventArgs.Empty);
}
if (this.Estado == EEstado.EnViaje)
{
InformaEstado(this.estado, EventArgs.Empty);
this.Estado = EEstado.EnViaje;
}
if (this.Estado == EEstado.Ingresado)
{
InformaEstado(this.estado, EventArgs.Empty);
this.Estado = EEstado.Ingresado;
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Hará que el paquete cambie de estado
/// </summary>
public void MockCicloDeVida()
{
//Recorremos los estados del paquete con un while
while (this.estado != EEstado.Entregado)
{
Thread.Sleep(4000);//Genera una demora de 4 segundos
if (this.Estado != EEstado.Entregado && this.Estado != EEstado.EnViaje)
{
this.Estado = EEstado.EnViaje;
}
else if (this.Estado != EEstado.Entregado && this.Estado == EEstado.EnViaje)
{
this.estado = EEstado.Entregado;
}
this.InformaEstado.Invoke(null, null);
if (this.estado == EEstado.Entregado)
{
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception)
{
}
}
}
}
public void MockCicloDeVida()
{
do
{
this.InformaEstado.Invoke(this, null);
Thread.Sleep(10000);
if (this.Estado == EEstado.ingresado)
{
this.Estado = EEstado.en_viaje;
}
else
{
this.Estado = EEstado.entregado;
}
} while (this.Estado != EEstado.entregado);
this.InformaEstado.Invoke(this, null);
try
{
PaqueteDAO.Insertar(this); //LLAMA PARA INSERTAR EN LA BASE DE DATOS
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error Base de Datos");
//throw new TrackingIdRepetidoException(e.Message);
}
}
public void MockCicloDeVida()
{
bool ok = false;
while (!ok)
{
Thread.Sleep(10000);
if (this._estado == EEstado.Ingresado)
{
this._estado = EEstado.EnViaje;
}
else if (this._estado == EEstado.EnViaje)
{
this._estado = EEstado.Entregado;
}
else if (this._estado == EEstado.Entregado)
{
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
InformaEstado(e, null);
}
finally
{
ok = true;
}
}
InformaEstado(this, null);
}
}
/// <summary>
/// Genera el ciclo de vida del paquete, cambiando su estado cada 10 segundos
/// Al llegar al estado entregado, se guarda el paquete en la base de datos especificada en PaqueteDAO
/// </summary>
public void MockCicloDeVida()
{
do
{
Thread.Sleep(10000);
if (this.estado == EEstado.Ingresado)
{
this.estado = EEstado.EnViaje;
}
else
{
this.estado = EEstado.Entregado;
}
InformaEstado(this, EventArgs.Empty);
} while (this.estado != EEstado.Entregado);
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
throw e;
}
}
public void MockCicloDeVida()
{
try
{
do
{
switch (estado)
{
case EEstado.Ingresado:
Thread.Sleep(4000);
estado = EEstado.EnViaje;
InformarEstado(this, new EventArgs());
break;
case EEstado.EnViaje:
Thread.Sleep(4000);
estado = EEstado.Entregado;
InformarEstado(this, new EventArgs());
break;
}
} while (estado != EEstado.Entregado);
PaqueteDAO.Insertar(this);
}
catch (Exception ex)
{
Notifica.Send(ex.Message, ETipoExcepcion.sql);
throw ex;
}
}
/// <summary>
/// El ciclo de vida del producto que cambia de estado hasta ser entregado
/// </summary>
public void MockCicloDeVida()
{
bool cicloDeVida = true;
//Lanza el evento, lo duerme 4 segundos, pasa al siguiente estado hasta llegar a ser entregado
while (cicloDeVida == true)
{
InformarEstado.Invoke(this, EventArgs.Empty);
Thread.Sleep(4000);
if (this.Estado == EEstado.Entregado)
{
break;
}
this.Estado++;
}
try
{
//Guarda en base de datos
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
throw new Exception("No pudo insertar en BD", e);
}
}
public void MockCicloDeVida()
{
while (Estado != EEstado.Entregado)
{
Thread.Sleep(10000);
switch (Estado)
{
case EEstado.Ingresado:
Estado = EEstado.EnViaje;
break;
case EEstado.EnViaje:
default:
Estado = EEstado.Entregado;
break;
}
this.InformaEstado(this, EventArgs.Empty);
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
// throw new Exception(ex.Message);
}
}
/// <summary>
/// Cada 4 segudos cambiara de estado al paquete, se informara el cambio de estado. Al llegar al ultimo estado se cargara el paquete a una base de datos.
/// </summary>
public void MockCicloDeVida()
{
while (true)
{
Thread.Sleep(4000);
if (this.Estado != EEstado.Entregado)
{
this.Estado++;
this.InformarEstado(this, new EventArgs());
}
else
{
this.InformarEstado(this, new EventArgs());
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
this.InformarEstado(e, new EventArgs());
}
break;
}
}
}
/// <summary>
/// MockCicloDeVida hará que el paquete cambie de estado de la siguiente forma:
//Colocar una demora de 4 segundos.
//Pasar al siguiente estado.
//Informar el estado a través de InformarEstado. EventArgs no tendrá ningún dato extra.
//Repetir las acciones desde el punto A hasta que el estado sea Entregado.
//Finalmente guardar los datos del paquete en la base de datos
/// </summary
public void MockCicloDeVida()
{
do
{
Thread.Sleep(4000);
if (this.estado == EEstado.Ingresado)
{
this.estado = EEstado.EnViaje;
}
else if (this.estado == EEstado.EnViaje)
{
this.estado = EEstado.Entregado;
}
this.InformarEstado(this, new EventArgs());
} while (this.estado != EEstado.Entregado);
if (this.Estado == EEstado.Entregado)
{
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception)
{
}
}
}
/// <summary>
/// Cambia el estado del paquete de la siguiente forma:
/// a.Coloca una demora de 4 segundos.
/// b.Pasa al siguiente estado.
/// c.Informa el estado a través del evento InformarEstado.
/// d.Repite las acciones desde el punto A hasta que el estado sea Entregado.
/// e.Finalmente guardar los datos del paquete en la base de datos
/// f.En caso de producirse un error se informa mediante el evento InformaExcepcion.
/// </summary>
public void MockCicloDeVida()
{
try
{
// Se iterará hasta que el estado del paquete sea Entregado.
while ((int)this.Estado <= 2)
{
// En caso de que halla algún manejador agregado al evento se lanza InformaEstado.
if (InformaEstado != null)
{
InformaEstado(this, null);
}
// Pausa de 4 segundos.
Thread.Sleep(4000);
// Si el estado no es Entregado se cambia al estado próximo.
if ((int)this.Estado < 2)
{
int i = (int)this.Estado + 1;
this.Estado = (EEstado)i;
}
else
{
break;
}
}
//Se inserta el paquete en la base de datos una vez que el paquete llega el estado Entregado.
PaqueteDAO.Insertar(this);
}
catch (Exception ex)
{
// En caso de error se dispara otro evento que puede manejar una excepción.
InformaExcepcion(this, ex);
}
}
public void MockCicloDeVida()
{
while (Estado != EEstado.Entregado)
{
this.InformaEstado.Invoke(this, null);
Thread.Sleep(1000);
if (this.Estado == EEstado.Ingesado)
{
this.Estado = EEstado.EnViaje;
}
else if (this.Estado == EEstado.EnViaje)
{
this.Estado = EEstado.Entregado;
}
}
this.InformaEstado.Invoke(this, null);
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception ex)
{
throw ex;
}
}
public void MockCicloDeVida()
{
Thread.Sleep(4000);
estado = EEstado.EnViaje;
if (this.InformarEstado != null)
{
InformarEstado.Invoke(this, null);
}
Thread.Sleep(4000);
estado = EEstado.Entregado;
if (this.InformarEstado != null)
{
InformarEstado.Invoke(this, null);
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception ex)
{
if (this.InformarError != null)
{
InformarError.Invoke(ex.Message + " paquete con TrakingId = " + this.trackingID, null);
}
}
}
public void MockCicloDeVida()
{
while (this.Estado != EEstado.Entregado)
{
Thread.Sleep(4000);
if (this.Estado == EEstado.Ingresado)
{
this.Estado = EEstado.EnViaje;
}
else if (this.Estado == EEstado.EnViaje)
{
this.Estado = EEstado.Entregado;
}
DelegadoEstado delegado = this.InformarEstado;
delegado(this, null);
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
throw e;
}
}
public void MockCicloDeVida()
{
do
{
this.InformaEstado.Invoke(this, null);
Thread.Sleep(10000);
if (this.Estado == EEstado.ingresado)
{
this.Estado = EEstado.en_viaje;
}
else
{
this.Estado = EEstado.entregado;
}
} while (this.Estado != EEstado.entregado);
this.InformaEstado.Invoke(this, null);
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Agrega un paquete a la lista de paquetes comprobando que el mismo ya no se encuentre guardado. Crea un hilo, lo inicializa y lo agrega a la lista de hilos. Graba los datos del paquete en la base de datos.
/// </summary>
/// <param name="c"></param>
/// <param name="p"></param>
/// <returns></returns>
public static Correo operator +(Correo c, Paquete p)
{
foreach (Paquete aux in c.Paquetes)
{
if (aux == p)
{
throw new TrackingIdRepetidoException($"El Tracking ID {aux.TrackingID} ya figura en la lista de envios.");
}
}
try
{
c.Paquetes.Add(p);
PaqueteDAO.Insertar(p);
Thread hiloPaquete = new Thread(p.MockCicloDeVida);
c.mockPaquetes.Add(hiloPaquete);
hiloPaquete.Start();
return(c);
}
catch (Exception e)
{
throw new Exception("Se produjo un error al intentar guardar el paquete en la base de datos.", e.InnerException);
}
}
/// <summary>
/// MockCicloDeVida hará que el paquete cambie de estado de la siguiente forma:
/// a.Colocar una demora de 4 segundos.
/// b.Pasar al siguiente estado.
/// c.Informar el estado a través de InformarEstado.EventArgs no tendrá ningún dato extra.
/// d.Repetir las acciones desde el punto A hasta que el estado sea Entregado.
/// e.Finalmente guardar los datos del paquete en la base de datos
/// </summary>
public void MockCicloDeVida()
{
do
{
this.InformaEstado.Invoke(this, null);
Thread.Sleep(4000);
if (this.Estado == EEstado.Ingresado)
{
this.Estado = EEstado.EnViaje;
}
else
{
this.Estado = EEstado.Entregado;
}
} while (this.Estado != EEstado.Entregado);
this.InformaEstado.Invoke(this, null);
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error en Base de Datos");
}
}
public void MockCicloDeVida()
{
while (this.Estado != EEstado.Entregado)
{
Thread.Sleep(4000);
switch (this.Estado)
{
case EEstado.Ingresado:
this.Estado = EEstado.EnViaje;
break;
case EEstado.EnViaje:
this.Estado = EEstado.Entregado;
break;
}
DelegadoEstado delegado = this.InformaEstado;
delegado(this, null);
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Cambia el estado del paquete cada 4 segundos
/// </summary>
public void MockCicloDeVida()
{
while (this.estado != EEstado.Entregado)
{
switch (this.estado)
{
case EEstado.Ingresado:
Thread.Sleep(4000);
this.Estado = EEstado.EnViaje;
this.InformaEstado(this, EventArgs.Empty);
break;
case EEstado.EnViaje:
Thread.Sleep(4000);
this.Estado = EEstado.Entregado;
this.InformaEstado(this, EventArgs.Empty);
break;
default:
break;
}
}
try
{
PaqueteDAO.Insertar(this);
}
catch (Exception exception)
{
throw exception;
}
}
public void MockCicloDeVida()
{
do
{
System.Threading.Thread.Sleep(4000);
switch (this.Estado)
{
case EEstado.Ingresado:
this.Estado = EEstado.EnViaje;
this.InformaEstado.Invoke(this, new EventArgs());
break;
case EEstado.EnViaje:
this.Estado = EEstado.Entregado;
this.InformaEstado.Invoke(this, new EventArgs());
break;
default:
break;
}
}while(this.Estado != EEstado.Entregado);
try
{
PaqueteDAO.Insertar(this);
}
catch (TrackingIdRepetidoException excepcionNoEsperada)
{ throw excepcionNoEsperada; }
catch (Exception Tira)
{ throw Tira; }
}
public void MockCicloDeVida()
{
while (this.estado != EEstado.Entregado)
{
Thread.Sleep(2000);
this.estado++;
this.InformarEstado.Invoke(this, null);
}
PaqueteDAO.Insertar(this);
}
/// <summary>
/// Hace que un paquete cambie de estado en un tiempo determinado
/// </summary>
public void MockCicloDeVida()
{
while (this.Estado != EEstado.Entregado)
{
Thread.Sleep(4000);
this.Estado += 1;
this.InformaEstado(this, new EventArgs());
}
PaqueteDAO.Insertar(this);
}
