示例#1
0
 /// <summary>
 /// Define la transaccción que actualiza un circuito
 /// </summary>
 /// <param name="circuit">El circuito actualizar.</param>
 /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
 public static void UpdateCircuitTr(this Circuito circuit, Action <Object> task_completed, double longitud = Double.NaN, double fac_agrup = Double.NaN, string interruptor = null, string calibre = null)
 {
     KeyValuePair <string, object>[] updateData = new KeyValuePair <string, object>[]
     {
         !Double.IsNaN(longitud) ? new KeyValuePair <string, object>("longitud", longitud) : new KeyValuePair <string, object>(String.Empty, null),
         !Double.IsNaN(fac_agrup) ? new KeyValuePair <string, object>("fac_agrup", fac_agrup) : new KeyValuePair <string, object>(String.Empty, null),
         interruptor != null ? new KeyValuePair <string, object>("interruptor", interruptor) : new KeyValuePair <string, object>(String.Empty, null),
         calibre != null ? new KeyValuePair <string, object>("calibre", calibre) : new KeyValuePair <string, object>(String.Empty, null)
     }.Where(x => x.Key != String.Empty).ToArray();
     if (updateData.Length > 0)
     {
         SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
         {
             TransactionTask = (SQLite_Connector conn, Object input) =>
             {
                 Object[] data  = input as Object[];
                 var      cto   = data[0] as Circuito;
                 var      uData = data[1] as KeyValuePair <string, object>[];
                 return(cto.Update(conn, uData));
             },
             TaskCompleted = (Object result) => { task_completed(result); }
         };
         tr.Run(new Object[] { circuit, updateData });
     }
 }
        /// <summary>
        /// Actualizá la ruta de guardado de un tablero
        /// </summary>
        /// <param name="tablero">El tablero a guardar.</param>
        /// <param name="savePath">La ruta del tablero a guardar.</param>
        private static void UpdateTableroPathTr(Tablero tablero, string savePath, Action <Object> task_completed = null)
        {
            KeyValuePair <string, object>[] updateData = new KeyValuePair <string, object>[]
            {
                savePath != null ? new KeyValuePair <string, object>("ruta", savePath) : new KeyValuePair <string, object>(String.Empty, null)
            }.Where(x => x.Key != String.Empty).ToArray();
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = (SQLite_Connector conn, Object input) =>
                {
                    Boolean flag = false;
                    String  msg  = String.Empty;
                    try
                    {
                        Object[] data  = input as Object[];
                        Tablero  tab   = data[0] as Tablero;
                        var      uData = data[1] as KeyValuePair <string, object>[];
                        flag = tab.Update(conn, uData);
                        if (flag)
                        {
                            tab.Path = uData[0].Value.ToString();
                        }
                        msg = "El tablero ha sido actualizado";
                    }
                    catch (Exception exc)
                    {
                        msg = exc.Message;
                    }
                    return(new Object[] { flag, msg });
                },
                TaskCompleted = (Object obj) => { task_completed(obj); },
            };

            tr.Run(new Object[] { tablero, updateData });
        }
        /// <summary>
        /// Creates the extra data and destinations.
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <param name="extraData">The extra data.</param>
        /// <param name="alimoAddedTask">The alimo added task.</param>
        /// <exception cref="NotImplementedException"></exception>
        private static void CreateExtraDataAndDestinations(int alimId, ExtraData extraData, Action <object, int> connectionCreated)
        {
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = CreateExtraDataConnections,
                TaskCompleted   = (Object result) => { connectionCreated(result, alimId); }
            };

            tr.Run(new Object[] { alimId, extraData });
        }
        /// <summary>
        /// Crea la conexión del alimentador
        /// </summary>
        /// <param name="alimId">El id del alimentador.</param>
        /// <param name="conn_id">El id del elemento conectado.</param>
        /// <param name="typeId">El tipo de elemento conectado al alimentador.</param>
        /// <param name="connectionCreated">La tarea a ejecutarse una vez que la conexión fue creada.</param>
        private static void CreateAlimentadorDestinationTr(int alimId, int conn_id, int typeId, Action <Object, int> connectionCreated)
        {
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = CreateAlimentadorConnection,
                TaskCompleted   = (Object result) => { connectionCreated(result, alimId); }
            };

            tr.Run(new Object[] { alimId, conn_id, typeId });
        }
        /// <summary>
        /// Creates the motor and destinations.
        /// </summary>
        /// <param name="alimId">The alim identifier.</param>
        /// <param name="motors">The motors.</param>
        /// <param name="connectionCreated">The connection created.</param>
        private static void CreateMotorAndDestinations(int alimId, IEnumerable <BigMotor> motors, Action <object, int> connectionCreated)
        {
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = CreateMotorsConnections,
                TaskCompleted   = (Object result) => { connectionCreated(result, alimId); }
            };

            tr.Run(new Object[] { alimId, motors });
        }
        /// <summary>
        /// Crea un nuevo alimentador y lo guarda en la aplicación
        /// </summary>
        /// <param name="alimentador">El tablero a insertar</param>
        /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
        public static void CreateAlimentadorTr(this AlimInput alimentador, Action <Object> task_completed)
        {
            //1: Se agregá el tablero a la aplicación
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = InsertAlimTask,
                TaskCompleted   = (Object result) => { task_completed(result); }
            };

            tr.Run(alimentador);
        }
        /// <summary>
        /// Crea un nuevo tablero y lo guarda en la aplicación
        /// </summary>
        /// <param name="tablero">El tablero a insertar</param>
        /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
        public static void CreateTableroTr(this Tablero tablero, Action <Object> task_completed)
        {
            //1: Se agregá el tablero a la aplicación
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = InsertTableroTask,
                TaskCompleted   = (Object result) => { task_completed(result); }
            };

            tr.Run(tablero);
        }
示例#8
0
        /// <summary>
        /// Define la transacción que elimina un circuito
        /// </summary>
        /// <param name="circuit">El circuito a eliminar.</param>
        /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
        public static void DeleteCircuitTr(this Circuito circuit, Action <Object> task_completed)
        {
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = (SQLite_Connector conn, Object input) =>
                {
                    Circuito cto = input as Circuito;
                    return(cto.Delete(conn));
                },
                TaskCompleted = (Object result) => { task_completed(result); }
            };

            tr.Run(circuit);
        }
        /// <summary>
        /// Define la transacción que elimina un tablero
        /// </summary>
        /// <param name="tablero">El tablero a eliminar.</param>
        /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
        public static void DeleteTableroTr(this Tablero tablero, Action <Object> task_completed)
        {
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = (SQLite_Connector conn, Object input) =>
                {
                    Tablero tab = input as Tablero;
                    return(tab.Delete(conn));
                },
                TaskCompleted = (Object result) => { task_completed(result); }
            };

            tr.Run(tablero);
        }
        /// <summary>
        /// Guarda una copia del tablero en la ruta del archivo especificado.
        /// </summary>
        /// <param name="filePath">La ruta en donde se guardará el archivo.</param>
        /// <param name="saveInput">Los parametros de entrada que recibe la función de guardado.</param>
        private static Boolean SaveTablero(String filePath, Object saveInput)
        {
            var             data           = (Object[])saveInput;
            Tablero         tablero        = data[0] as Tablero;
            Action <Object> task_completed = data[1] as Action <Object>;
            Boolean         flag           = false;

            try
            {
                //Copiamos el archivo base de tableros
                File.Copy(TabalimApp.TableroDBPath, filePath, tablero.Path == filePath);
                SQLiteWrapper tr = new SQLiteWrapper(filePath)
                {
                    TransactionTask = (SQLite_Connector conn, Object input) =>
                    {
                        try
                        {
                            List <Componente> cmps;
                            List <Circuito>   ctos;
                            Tablero           t = ((Tablero)input).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)));
                            return(new object[] { true, String.Format("Tablero guardado de forma correcta en \n{0}.", filePath) });
                        }
                        catch (Exception exc)
                        {
                            return(new object[] { false, String.Format("Error al guardar el tablero\nDetalles: {0}", exc.Message) });
                        }
                    },
                    TaskCompleted = (Object result) => { task_completed(result); }
                };
                tr.Run(tablero);
                flag = true;
            }
            catch (IOException exc)
            {
                task_completed(new object[] { false, String.Format("Error al guardar el tablero\nDetalles: {0}\nPara remplazar el archivo utilice guardar como.", exc.Message) });
            }
            catch (Exception exc)
            {
                task_completed(new object[] { false, String.Format("Error al guardar el tablero\nDetalles: {0}", exc.Message) });
            }
            return(flag);
        }
        /// <summary>
        /// Importa un tablero al proyecto seleccionado
        /// </summary>
        /// <param name="window">La ventana que llama a esta función</param>
        /// <param name="project">El proyecto al cual se le importará un tablero.</param>
        /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
        public static void ImportTableroTr(this MetroWindow window, Project project, Action <Object> task_completed)
        {
            FileManager fm = new FileManager("Tabalim", "Abrir Tablero", "tabalim");
            String      filePath;

            if (fm.PickPath(out filePath))
            {
                try
                {
                    SQLiteWrapper tr = new SQLiteWrapper(filePath)
                    {
                        TransactionTask = PickTableroName,
                        TaskCompleted   = async(Object result) =>
                        {
                            Tablero fileTablero = result as Tablero;
                            String  tabName     = fileTablero.NombreTablero;
                            Tablero existant    = project.Tableros.Values.FirstOrDefault(x => x.NombreTablero == tabName);
                            if (existant != null)
                            {
                                MessageDialogResult res = await window.ShowMessageAsync("Tablero Existente", "El tablero ya existe en el proyecto actual\n¿Quiere remplazarlo?", MessageDialogStyle.AffirmativeAndNegative);

                                if (res == MessageDialogResult.Affirmative)
                                {
                                    DeleteTableroAndLoadTr(project, existant, fileTablero, task_completed);
                                }
                            }
                            else
                            {
                                LoadTableroTr(project, fileTablero, task_completed);
                            }
                        }
                    };
                    tr.Run(null);
                }
                catch (Exception exc)
                {
                    task_completed(new object[] { false, String.Format("Error al abrir el tablero\nDetalles: {0}", exc.Message) });
                }
            }
            else
            {
                task_completed(new object[] { false, String.Empty });
            }
        }
        /// <summary>
        /// Realizá la carga del tablero
        /// </summary>
        /// <param name="project">El nombre del proyecto.</param>
        /// <param name="fileTablero">El tablero leido del archivo.</param>
        /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
        private static void LoadTableroTr(Project project, Tablero fileTablero, Action <object> task_completed)
        {
            SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
            {
                TransactionTask = (SQLite_Connector conn, Object input) =>
                {
                    Object[] data    = input as Object[];
                    Project  prj     = data[0] as Project;
                    Tablero  fileTab = data[1] as Tablero;
                    return(InsertTableroTr(conn, prj, fileTab));
                },
                TaskCompleted = (Object result) =>
                {
                    task_completed(result);
                }
            };

            tr.Run(new Object[] { project, fileTablero });
        }
 /// <summary>
 /// Define la transacción que actualiza un tablero
 /// El nombre del tablero debe ser único
 /// </summary>
 /// <param name="tablero">El tablero actualizar.</param>
 /// <param name="project">El proyecto al que pertenece el tablero.</param>
 /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
 /// <param name="tab_name">El nombre del tablero.</param>
 /// <param name="tab_desc">La descripción del tablero.</param>
 public static void UpdateTableroTr(this Tablero tablero, Project project, Action <Object> task_completed,
                                    String tab_name = null, string tab_desc = null)
 {
     KeyValuePair <string, object>[] updateData = new KeyValuePair <string, object>[]
     {
         tab_name != null ? new KeyValuePair <string, object>("tab_name", tab_name) : new KeyValuePair <string, object>(String.Empty, null),
         tab_desc != null ? new KeyValuePair <string, object>("tab_desc", tab_desc) : new KeyValuePair <string, object>(String.Empty, null)
     }.Where(x => x.Key != String.Empty).ToArray();
     if (updateData.Length > 0)
     {
         SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
         {
             TransactionTask = (SQLite_Connector conn, Object input) =>
             {
                 Boolean flag = false;
                 String  msg  = String.Empty;
                 try
                 {
                     Object[] data      = input as Object[];
                     Tablero  tab       = data[0] as Tablero;
                     var      uData     = data[1] as KeyValuePair <string, object>[];
                     Project  prj       = data[2] as Project;
                     var      uDataName = uData.FirstOrDefault(x => x.Key == "tab_name");
                     if ((uDataName.Value != null && uDataName.Value.ToString() != tab.NombreTablero) &&
                         prj.Tableros.Values.Count(x => x.NombreTablero == uDataName.Value.ToString()) > 0)
                     {
                         throw new Exception("El nombre del tablero ya existe en el proyecto.\n Favor de utilizar otro nombre.");
                     }
                     flag = tab.Update(conn, uData);
                     msg  = "El tablero ha sido actualizado";
                 }
                 catch (Exception exc)
                 {
                     msg = exc.Message;
                 }
                 return(new Object[] { flag, msg });
             },
             TaskCompleted = (Object obj) => { task_completed(obj); },
         };
         tr.Run(new Object[] { tablero, updateData, project });
     }
 }
示例#14
0
 /// <summary>
 /// Define la transacción que actualiza un componente
 /// </summary>
 /// <param name="component">El componente actualizar.</param>
 /// <param name="tablero">El tablero actualizar.</param>
 /// <param name="task_completed">La tarea que se ejecuta al terminar la transacción.</param>
 /// <param name="cto">El nuevo circuito.</param>
 /// <param name="cmp_count">El número total de componentes.</param>
 /// <param name="potencia">La potencia del circuito.</param>
 public static void UpdateComponentTr(this Componente component, Tablero tablero, Action <Object> task_completed, Circuito circuit = null, int cmp_count = 0, Potencia potencia = null)
 {
     KeyValuePair <string, object>[] updateData = new KeyValuePair <string, object>[]
     {
         circuit != null ? new KeyValuePair <string, object>("cir_id", circuit) : new KeyValuePair <string, object>(String.Empty, null),
         cmp_count > 0 ? new KeyValuePair <string, object>("comp_count", cmp_count) : new KeyValuePair <string, object>(String.Empty, null),
         potencia != null ? new KeyValuePair <string, object>("potencia", potencia) : new KeyValuePair <string, object>(String.Empty, null)
     }.Where(x => x.Key != String.Empty).ToArray();
     if (updateData.Length > 0)
     {
         SQLiteWrapper tr = new SQLiteWrapper(TabalimApp.AppDBPath)
         {
             TransactionTask = (SQLite_Connector conn, Object input) =>
             {
                 Object[]   data  = input as Object[];
                 Componente cmp   = data[0] as Componente;
                 var        uData = data[1] as KeyValuePair <string, object>[];
                 Circuito   cto   = data[2] as Circuito;
                 Tablero    tab   = data[3] as Tablero;
                 //Crear el circuito
                 if (cto != null && cto.Id < 1)
                 {
                     cto = conn.InsertCircuitTr(cto, tab);
                     tab.Circuitos.Add(cto.ToString(), cto);
                     int index = uData.Select(x => x.Key).ToList().IndexOf("cir_id");
                     uData[index] = new KeyValuePair <string, object>("cir_id", cto);
                     if (cmp.Circuito.Componentes.Count == 1)
                     {
                         conn.Delete(TABLE_CIRCUIT, cmp.Circuito.CreatePrimaryKeyCondition());
                     }
                 }
                 return(cmp.Update(conn, uData));
             },
             TaskCompleted = (Object obj) => { task_completed(obj); },
         };
         tr.Run(new Object[] { component, updateData, circuit, tablero });
     }
 }
示例#15
0
        /// <summary>
        /// Define una transacción que agregá un componente a un tablero
        /// </summary>
        /// <param name="tablero">El tablero</param>
        /// <param name="component">El componente agregar</param>
        public static void AddComponentTr(this Tablero tablero, Componente component, Action <Object> componenteAddedTask = null)
        {
            //Primero se guarda el circuito
            SQLiteWrapper tr       = new SQLiteWrapper(TabalimApp.AppDBPath);
            Circuito      circuito = component.Circuito;

            //Se revisa si el ciruito ya existe
            if (tablero.Circuitos.ContainsKey(circuito.ToString()))
            {
                tr.TransactionTask = (SQLite_Connector conn, Object input) =>
                {
                    Object[]   data = (Object[])input;
                    Circuito   cto  = data[0] as Circuito;
                    Componente cmp  = conn.InsertComponentTr(data[1] as Componente, cto);
                    return(new Object[] { cmp.Id > 0, cto, cmp });
                }
            }
            ;
            else
            {
                tr.TransactionTask = (SQLite_Connector conn, Object input) =>
                {
                    Object[]   data = (Object[])input;
                    Tablero    tab  = data[2] as Tablero;
                    Circuito   cto  = conn.InsertCircuitTr(data[0] as Circuito, tab);
                    Componente cmp  = conn.InsertComponentTr(data[1] as Componente, cto);
                    return(new Object[] { cto.Id > 0 && cmp.Id > 0, cto, cmp });
                }
            };
            tr.TaskCompleted = (Object qResult) =>
            {
                Object[] result = qResult as Object[];
                bool     succed = (bool)result[0];
                if (succed)
                {
                    Circuito   cto = (Circuito)result[1];
                    Componente cmp = (Componente)result[2];
                    if (!tablero.Circuitos.ContainsKey(cto.ToString()))
                    {
                        tablero.Circuitos.Add(cto.ToString(), cto);
                    }
                    if (!tablero.Componentes.ContainsKey(cmp.Id))
                    {
                        tablero.Componentes.Add(cmp.Id, cmp);
                    }
                    if (!cto.Componentes.ContainsKey(cmp.Id))
                    {
                        cto.Componentes.Add(cmp.Id, cmp);
                    }
                    if (componenteAddedTask != null)
                    {
                        componenteAddedTask(cto);
                    }
                }
                else
                {
                    throw new Exception("Error al anexar el componente.");
                }
            };
            tr.Run(new Object[] { circuito, component, TabalimApp.CurrentTablero });
        }
        /// <summary>
        /// Guarda una copia del tablero en la ruta del archivo especificado.
        /// </summary>
        /// <param name="filePath">La ruta en donde se guardará el archivo.</param>
        /// <param name="saveInput">Los parametros de entrada que recibe la función de guardado.</param>
        private static Boolean SaveTableroAs(String filePath, Object saveInput)
        {
            var               data           = (Object[])saveInput;
            Tablero           tablero        = data[0] as Tablero;
            List <Componente> componentes    = data[1] as List <Componente>;
            List <Circuito>   circuitos      = data[2] as List <Circuito>;
            Action <Object>   task_completed = data[3] as Action <Object>;
            Boolean           flag           = false;

            try
            {
                SQLiteWrapper.QuickTransaction(TabalimApp.AppDBPath, (SQLite_Connector conn, Object[] input) =>
                {
                    String query = TABLE_TABLERO.SelectAll(String.Format("ruta ='{0}'", filePath));
                    Tablero t    = conn.Select <Tablero>(query).FirstOrDefault();
                    if (t != null)
                    {
                        t.LoadComponentesAndCircuits(conn, t);
                        t.Delete(conn);
                    }
                }, filePath);
                //Copiamos el archivo base de tableros
                File.Copy(TabalimApp.TableroDBPath, filePath, true);
                SQLiteWrapper tr = new SQLiteWrapper(filePath)
                {
                    TransactionTask = (SQLite_Connector conn, Object input) =>
                    {
                        try
                        {
                            Object[]          tData = input as Object[];
                            Tablero           t     = tData[0] as Tablero;
                            List <Componente> cmps  = tData[1] as List <Componente>;
                            List <Circuito>   ctos  = tData[2] as List <Circuito>;
                            //Primero se realiza la copia externa, luego la interna
                            if (InsertTablero(conn, t, cmps, ctos))
                            {
                                var localClone = t.Clone(out cmps, out ctos);
                                SQLiteWrapper.QuickTransaction(TabalimApp.AppDBPath,
                                                               (SQLite_Connector localConn, Object[] localInput) =>
                                {
                                    (localInput[0] as Tablero).Path = localInput[3] as String;
                                    var succed = InsertTablero(localConn,
                                                               localInput[0] as Tablero,
                                                               localInput[1] as List <Componente>,
                                                               localInput[2] as List <Circuito>);
                                    Tablero nT = localInput[0] as Tablero;
                                    if (succed && !TabalimApp.CurrentProject.Tableros.ContainsKey(nT.Id))
                                    {
                                        TabalimApp.CurrentProject.Tableros.Add(nT.Id, nT);
                                    }
                                }, t, cmps, ctos, new SQLiteConnectionStringBuilder(conn.Connection.ConnectionString).DataSource);
                            }
                            return(new object[] { true, String.Format("Tablero guardado de forma correcta en \n{0}.", filePath) });
                        }
                        catch (Exception exc)
                        {
                            return(new object[] { false, String.Format("Error al guardar el tablero\nDetalles: {0}", exc.Message) });
                        }
                    },
                    TaskCompleted = (Object result) => { task_completed(result); }
                };
                tr.Run(new object[] { tablero, componentes, circuitos });
                flag = true;
            }
            catch (IOException exc)
            {
                task_completed(new object[] { false, String.Format("Error al guardar el tablero\nDetalles: {0}\nPara remplazar el archivo utilice guardar como.", exc.Message) });
            }
            catch (Exception exc)
            {
                task_completed(new object[] { false, String.Format("Error al guardar el tablero\nDetalles: {0}", exc.Message) });
            }
            return(flag);
        }