/// <summary>
/// Maneja el evento que realizá la tárea
/// </summary>
/// <param name="sender">La fuente del evento.</param>
/// <param name="e">Los argumentos de tipo <see cref="DoWorkEventArgs"/> que contienen la información del evento.</param>
private void BGW_DoWork(object sender, DoWorkEventArgs e)
{
if (this.TransactionTask == null)
{
throw new Exception("No se ha definido acción para la transacción.");
}
try
{
Object[] input = (Object[])e.Argument;
String dpPath = (string)input[0];
using (SQLite_Connector conn = new SQLite_Connector(dpPath))
{
try
{
e.Result = this.TransactionTask(conn, input[1]);
}
catch (System.Exception exc)
{
throw exc;
}
}
}
catch (Exception exc)
{
throw exc;
}
}
/// <summary>
/// Creates the motors connections.
/// </summary>
/// <param name="conn">The connection.</param>
/// <param name="input">The input.</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
private static object CreateMotorsConnections(SQLite_Connector conn, object input)
{
try
{
Object[] data = input as Object[];
int alimId = (int)data[0];
IEnumerable <BigMotor> motors = (IEnumerable <BigMotor>)data[1];
Boolean flag;
DestinationRow row;
motors.ToList().ForEach(x =>
{
flag = x.Create(conn, null);
if (flag)
{
x.Id = (int)conn.SelectValue <long>("motores".SelectLastId(x.PrimaryKey));
row = new DestinationRow()
{
AlimId = alimId,
ConnId = x.Id,
TypeId = 0,
};
row.Create(conn, null);
}
});
return(motors.Count(x => x.Id > 0) > 0);
}
catch (Exception exc)
{
return(exc);
}
}
/// <summary>
/// Crea un wraper sencillo que realiza una transacción a la base
/// de datos y no retorna ningun valor
/// </summary>
/// <param name="path">The path.</param>
/// <param name="action">La acción que realizá la transacción.</param>
/// <param name="input">La entrada de la transacción.</param>
/// <exception cref="Exception">En caso de encontrar un error en la transacción o que no se haya definido alguna acción para la transacción.</exception>
public static void QuickTransaction(String path, Action <SQLite_Connector, Object[]> action, params Object[] input)
{
if (action == null)
{
throw new Exception("No se ha definido acción para la transacción.");
}
try
{
using (SQLite_Connector conn = new SQLite_Connector(path))
{
try
{
action(conn, input);
}
catch (System.Exception exc)
{
throw exc;
}
}
}
catch (Exception exc)
{
throw exc;
}
}
private static object CreateExtraDataConnections(SQLite_Connector conn, object input)
{
try
{
Object[] data = input as Object[];
int alimId = (int)data[0];
ExtraData extra = (ExtraData)data[1];
Boolean flag = extra.Create(conn, null);
if (flag)
{
extra.Id = (int)conn.SelectValue <long>("extras".SelectLastId(extra.PrimaryKey));
DestinationRow row = new DestinationRow()
{
AlimId = alimId,
ConnId = extra.Id,
TypeId = 2,
};
return(row.Create(conn, null));
}
return(false);
}
catch (Exception exc)
{
return(exc);
}
}
/// <summary>
/// Picks the name of the tablero.
/// </summary>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="input">La entrada de la transacción.</param>
/// <returns>El nombre del tablero</returns>
private static object PickTableroName(SQLite_Connector conn, object input)
{
Tablero tab = conn.Select <Tablero>(TABLE_TABLERO.SelectAll()).FirstOrDefault();
tab.LoadComponentesAndCircuits(conn, tab);
return(tab);
}
/// <summary>
/// Inserta un elemento, selecciona el último id del elemento insertado.
/// El id es asignado al elemento y es regresado en la función
/// </summary>
/// <typeparam name="T">El tipo de elemento a retornar</typeparam>
/// <param name="element">El elmento generico a insertar.</param>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="input">La entrada necesaria para insertar el elemento.</param>
/// <returns></returns>
public static T GetLastId <T>(this IDatabaseMappable element, SQLite_Connector conn, Object input)
where T : IDatabaseMappable
{
if (element.Create(conn, input))
{
element.Id = (int)conn.SelectValue <long>(element.TableName.SelectLastId(element.PrimaryKey));
}
return((T)element);
}
/// <summary>
/// Realiza el proceso de inserción de un tablero con sus componentes y circuitos separados
/// </summary>
/// <param name="conn">Define la conexión a SQLite.</param>
/// <param name="tablero">El tablero a insertar.</param>
/// <param name="componentes">Los componenentes asociados al tablero.</param>
/// <param name="circuitos">Los circuitos asociados al tablero.</param>
/// <returns>Verdadero si la inserción se realizá de manera correcta</returns>
private static Boolean InsertTablero(SQLite_Connector conn, Tablero tablero, List <Componente> componentes, List <Circuito> circuitos)
{
//Se inserta el tablero
InsertTableroTask(conn, tablero);
//Se se insertan los circuitos
circuitos.ForEach(x => x.GetLastId <Circuito>(conn, tablero));
//Se insertan los componentes
componentes.ForEach(cmp => cmp.GetLastId <Componente>(conn, circuitos.FirstOrDefault(cto => cto.ToString() == cmp.CircuitoName)));
tablero.LoadComponentesAndCircuits(conn, tablero);
return(conn.QuerySucced);
}
/// <summary>
/// Obtiene el resultado de selección
/// </summary>
/// <param name="query">El query de selección</param>
/// <param name="conn">La conexión a SQLite.</param>
/// <returns>El resultado de selección.</returns>
public static List <SelectionResult[]> GetCommandResult(this SQLite_Connector conn, string query)
{
List <SelectionResult[]> result = new List <SelectionResult[]>();
SQLiteCommand cmd = new SQLiteCommand(query, conn.Connection);
using (SQLiteDataReader reader = cmd.ExecuteReader())
while (reader.HasRows && reader.Read())
{
result.Add(reader.GetResult());
}
return(result);
}
/// <summary>
/// Define la tarea que inserta un alimentador
/// </summary>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="input">La entrada de la conexión debe ser un alimentador.</param>
/// <returns>El resultado de la transacción</returns>
private static object InsertAlimTask(SQLite_Connector conn, object input)
{
AlimInput alim = (AlimInput)input;
Boolean flag = false;
flag = alim.Create(conn, null);
if (flag)
{
alim.Id = (int)conn.SelectValue <long>("alimentador".SelectLastId(alim.PrimaryKey));
}
return(new Object[] { flag, alim.Id > 0 ? alim : null });
}
/// <summary>
/// Actualiza un elemento mediante una condición
/// </summary>
/// <param name="element">El elemento actualizar.</param>
/// <param name="condition">La condición a evaluar.</param>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="input">The input.</param>
/// <returns></returns>
public static Boolean UpdateTr(this ISQLiteParser element, string condition, SQLite_Connector conn, KeyValuePair <string, object>[] input)
{
UpdateField[] data = input.Select(x => element.PickUpdateFields(x)).Where(y => y != null).ToArray();
if (conn.Update(data, condition))
{
element.UpdateFields(input);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Inserta un nuevo tablero en la aplicación
/// </summary>
/// <param name="conn">La conexión activa al archivo de conexión.</param>
/// <param name="prj">El proyecto seleccionado.</param>
/// <param name="fileTablero">El tablero leido del archivo.</param>
/// <returns>El resultado de la transacción</returns>
private static object InsertTableroTr(SQLite_Connector conn, Project prj, Tablero fileTablero)
{
Boolean flag = false;
String msg = String.Empty;
Tablero result = null;
try
{
if (fileTablero != null)
{
try
{
List <Componente> cmps;
List <Circuito> ctos;
Tablero t = fileTablero.Clone(out cmps, out ctos);
//Se inserta el tablero
InsertTableroTask(conn, t);
//Se se insertan los circuitos
ctos.ForEach(x => x.GetLastId <Circuito>(conn, t));
//Se insertan los componentes
cmps.ForEach(cmp => cmp.GetLastId <Componente>(conn,
ctos.FirstOrDefault(cto => cto.ToString() == cmp.CircuitoName)));
result = t;
result.LoadComponentesAndCircuits(conn, result);
msg = String.Format("El tablero se cargo en el proyecto actual");
flag = true;
}
catch (Exception exc)
{
conn.Dispose();
msg = String.Format("Error al importar el tablero\nDetalles: {0}", exc.Message);
}
}
else
{
throw new Exception(String.Format("Error al leer el archivo\n", conn.Connection.DataSource));
}
}
catch (Exception exc)
{
msg = String.Format("Error al importar el tablero\nDetalles: {0}", exc.Message);
}
return(new Object[] { flag, msg, result });
}
/// <summary>
/// Crea la inserción del alimentador
/// </summary>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="input">La entrada para realizar la inserción.</param>
/// <returns>Una bandera que indica si se realizó la conexión</returns>
private static object CreateAlimentadorConnection(SQLite_Connector conn, object input)
{
try
{
Object[] data = input as Object[];
DestinationRow row = new DestinationRow()
{
AlimId = (int)data[0],
ConnId = (int)data[1],
TypeId = (int)data[2],
};
return(row.Create(conn, null));
}
catch (Exception exc)
{
return(exc);
}
}
private static object CreateTableroConnections(SQLite_Connector conn, object[] input)
{
try
{
Object[] data = input as Object[];
int alimId = (int)data[0];
IEnumerable <Tablero> cargas = (IEnumerable <Tablero>)data[1];
List <Object> result = new List <object>();
cargas.ToList().ForEach(x =>
{
result.Add(CreateAlimentadorConnection(conn, new Object[] { alimId, x.Id, 1 }));
});
return(result.Count(x => x is Exception) == 0 ? true : result.FirstOrDefault(y => y is Exception));
}
catch (Exception exc)
{
return(exc);
}
}
/// <summary>
/// Define la tarea que inserta un tablero
/// </summary>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="input">La entrada de la conexión debe ser un tablero.</param>
/// <returns>El resultado de la transacción</returns>
private static object InsertTableroTask(SQLite_Connector conn, object input)
{
Tablero tab = (Tablero)input;
if (tab.NombreTablero == "")
{
tab.NombreTablero = String.Format("Tablero {0:000}", TabalimApp.CurrentProject.Tableros.Count + 1);
}
if (tab.Description == "")
{
tab.Description = "Sin descripción";
}
Boolean flag = false;
flag = tab.Create(conn, null);
if (flag)
{
tab.Id = (int)conn.SelectValue <long>(TABLE_TABLERO.SelectLastId(tab.PrimaryKey));
}
return(new Object[] { flag, tab.Id > 0 ? tab : null });
}
/// <summary>
/// Creates the motors cargas connections.
/// </summary>
/// <param name="conn">The connection.</param>
/// <param name="input">The input.</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
private static object CreateMotorsCargasConnections(SQLite_Connector conn, object input)
{
Object[] data = input as Object[];
int alimId = (int)data[0];
IEnumerable <Tablero> cargas = (IEnumerable <Tablero>)data[1];
IEnumerable <BigMotor> motors = (IEnumerable <BigMotor>)data[2];
Object motorsResult = CreateMotorsConnections(conn, new Object[] { alimId, motors });
Object cargasResult = CreateTableroConnections(conn, new Object[] { alimId, cargas });
if (motorsResult is Boolean && cargasResult is Boolean)
{
return((Boolean)motorsResult && (Boolean)cargasResult);
}
else if (!(motorsResult is Boolean) && cargasResult is Boolean)
{
return(motorsResult);
}
else
{
return(cargasResult);
}
}
/// <summary>
/// Crea una transacción que inserta un componente en la base de datos
/// </summary>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="cmp">El componente a insertar.</param>
/// <param name="cto">El circuito al que se conecta el componente.</param>
/// <returns>El componente insertado</returns>
public static Componente InsertComponentTr(this SQLite_Connector conn, Componente cmp, Circuito cto)
{
return(cmp.GetLastId <Componente>(conn, cto));
}
/// <summary>
/// Crea una transacción que inserta un componente en la base de datos
/// </summary>
/// <param name="conn">La conexión a SQLite.</param>
/// <param name="cmp">El componente a insertar.</param>
/// <param name="cto">El circuito al que se conecta el componente.</param>
/// <returns>El componente insertado</returns>
public static Circuito InsertCircuitTr(this SQLite_Connector conn, Circuito cto, Tablero tab)
{
return(cto.GetLastId <Circuito>(conn, tab));
}
