示例#1
0
        public Boolean DeleteUsedCommand(UsedCommand cmd)
        {
            Boolean result = false;
            int r;

            try
            {
                base.Query = SP_DELETE_USED_COMMANDS;
                base.InsertParameter(0, cmd.Command_id);
                base.InsertParameter(1, cmd.User_id);
                base.InsertParameter(2, cmd.UsedDate);
                base.InsertParameter(3, cmd.IdSnoopy);
                base.InsertParameter(4, cmd.Num_params);
                base.InsertParameter(5, cmd.Parameters);

                r = base.ModuloDatos.ExecuteNonReader(base.Query);

                result = (r == 1);
            }
            catch (Exception ex)
            {
                result = false;
                base.ModuloLog.Error(ex);
            }

            return result;
        }
示例#2
0
        public Boolean UpdateUsedCommand(UsedCommand cmd, int id_cmd_original, int id_user_original, DateTime original_date, int id_snoopy_original, int num_params, String parameters)
        {
            Boolean result = false;
            int r;

            try
            {
                base.Query = SP_UPDATE_USED_COMMANDS;
                base.InsertParameter(0, cmd.Command_id);
                base.InsertParameter(1, cmd.User_id);
                base.InsertParameter(2, cmd.UsedDate);
                base.InsertParameter(3, cmd.IdSnoopy);
                base.InsertParameter(4, cmd.Num_params);
                base.InsertParameter(5, cmd.Parameters);
                base.InsertParameter(6, id_cmd_original);
                base.InsertParameter(7, id_user_original);
                base.InsertParameter(8, original_date);
                base.InsertParameter(9, id_snoopy_original);
                base.InsertParameter(10, num_params);
                base.InsertParameter(11, parameters);

                r = base.ModuloDatos.ExecuteNonReader(base.Query);

                result = (r == 1);
            }
            catch (Exception ex)
            {
                result = false;
                base.ModuloLog.Error(ex);
            }

            return result;
        }
示例#3
0
        private void FillUsedCommandsData(DataRow dRow, UsedCommand cmd)
        {
            object obj;

            obj = dRow["ID"];
            if (obj != DBNull.Value)
            {
                cmd.Id_commandUsed = Int32.Parse(obj.ToString());
            }
            obj = dRow["COMMAND_ID"];
            if (obj != DBNull.Value)
            {
                cmd.Command_id = Int32.Parse(obj.ToString());
            }
            obj = dRow["USER_ID"];
            if (obj != DBNull.Value)
            {
                cmd.User_id = Int32.Parse(obj.ToString());
            }

            //Jan 20 06:35:03
            obj = dRow["USE_DATE"];
            if (obj != DBNull.Value)
            {
                cmd.UsedDate = DateTime.Parse(obj.ToString());
            }
            obj = dRow["ID_SNOOPY"];
            if (obj != DBNull.Value)
            {
                cmd.IdSnoopy = Int32.Parse(obj.ToString());
            }
            obj = dRow["NUM_PARAMS"];
            if (obj != DBNull.Value)
            {
                cmd.Num_params = Int32.Parse(obj.ToString());
            }

            obj = dRow["PARAMS"];
            if (obj != DBNull.Value)
            {
                cmd.Parameters = obj.ToString();
            }
        }
示例#4
0
        public List<UsedCommand> GetUsedCommandsByIdSnoopy(int id_snoopy)
        {
            List<UsedCommand> listaComandosUsados = new List<UsedCommand>();
            UsedCommand cmd = new UsedCommand();
            DataSet ds = null;

            try
            {
                base.ModuloLog.Debug("Se consulta los comandos utilizados por ID_SNOOPY" + id_snoopy);

                base.Query = SP_SELECT_USED_COMMANDS_BY_ID_SNOOPY;
                base.InsertParameter(0, id_snoopy);

                ds = base.ModuloDatos.ExecuteDataSet(base.Query);

                foreach (DataTable dt in ds.Tables)
                {
                    foreach (DataRow dRow in dt.Rows)
                    {
                        cmd = new UsedCommand();
                        this.FillUsedCommandsData(dRow, cmd);
                        listaComandosUsados.Add(cmd);
                    }
                }
            }
            catch (Exception ex)
            {
                listaComandosUsados.Clear();
                base.ModuloLog.Error(ex);
            }
            return listaComandosUsados;
        }
示例#5
0
        public List<UsedCommand> GetUsedCommandsByUserId(int id_user)
        {
            List<UsedCommand> listaComandosUsados = new List<UsedCommand>();
            UsedCommand cmd = new UsedCommand();
            DataSet ds = null;

            try
            {
                base.ModuloLog.Debug("Se consultan las relaciones de comandos usados por id de usuario: " + id_user);

                base.Query = SP_SELECT_USED_COMMANDS_BY_USER;
                base.InsertParameter(0, id_user);

                ds = base.ModuloDatos.ExecuteDataSet(base.Query);

                foreach (DataTable dt in ds.Tables)
                {
                    foreach (DataRow dRow in dt.Rows)
                    {
                        cmd = new UsedCommand();
                        this.FillUsedCommandsData(dRow, cmd);
                        listaComandosUsados.Add(cmd);
                    }
                }
            }
            catch (Exception ex)
            {
                listaComandosUsados.Clear();
                base.ModuloLog.Error(ex);
            }
            return listaComandosUsados;
        }
示例#6
0
        public List<UsedCommand> GetUsedCommandsByDate(DateTime date)
        {
            List<UsedCommand> listaComandosUsados = new List<UsedCommand>();
            UsedCommand cmd = new UsedCommand();
            DataSet ds = null;

            try
            {
                base.ModuloLog.Debug("Se consultan las relaciones de comandos usados por fecha de uso: " + date.ToLongDateString());

                base.Query = SP_SELECT_USED_COMMANDS_BY_DATE;
                base.InsertParameter(0, date);

                ds = base.ModuloDatos.ExecuteDataSet(base.Query);

                foreach (DataTable dt in ds.Tables)
                {
                    foreach (DataRow dRow in dt.Rows)
                    {
                        cmd = new UsedCommand();
                        this.FillUsedCommandsData(dRow, cmd);
                        listaComandosUsados.Add(cmd);
                    }
                }
            }
            catch (Exception ex)
            {
                listaComandosUsados.Clear();
                base.ModuloLog.Error(ex);
            }
            return listaComandosUsados;
        }
示例#7
0
        public Boolean GetOneUsedCommand(UsedCommand cmd_original)
        {
            Boolean find = false;
            DataSet ds = null;

            try
            {
                base.ModuloLog.Debug("Se consulta si el registro con: COMMAND_ID = " + cmd_original.Command_id +
                                                                    " USER_ID = " + cmd_original.User_id +
                                                                    " USE_DATE = " + cmd_original.UsedDate.ToString("dd/MM/yyyy HH:mm:ss") +
                                                                    " ID_SNOOPY = " + cmd_original.IdSnoopy +
                                                                    " NUM_PARAMS = " + cmd_original.Num_params +
                                                                    " PARAMS = " + cmd_original.Parameters +
                                     " existe ya en la tabla COMMANDS_USED, o no.");

                base.Query = SP_SELECT_ONE_COMMANDS_USED;
                base.InsertParameter(0, cmd_original.Command_id);
                base.InsertParameter(1, cmd_original.User_id);
                base.InsertParameter(2, cmd_original.UsedDate.ToString("dd/MM/yyyy HH:mm:ss"));
                base.InsertParameter(3, cmd_original.IdSnoopy);
                base.InsertParameter(4, cmd_original.Num_params);
                base.InsertParameter(5, cmd_original.Parameters);

                ds = base.ModuloDatos.ExecuteDataSet(base.Query);

                foreach (DataTable dt in ds.Tables)
                {
                    foreach (DataRow dRow in dt.Rows)
                    {
                        find = true;
                    }
                }
            }
            catch (Exception ex)
            {
                base.ModuloLog.Error(ex);
                find = false;
            }
            return find;
        }
示例#8
0
        public List<UsedCommand> GetAllUsedCommands()
        {
            List<UsedCommand> listaComandosUsados = new List<UsedCommand>();
            UsedCommand cmd = new UsedCommand();
            DataSet ds = null;

            try
            {
                base.ModuloLog.Debug("Se consultan todos lo comandos usados almacenados.");

                base.Query = SP_SELECT_ALL_USED_COMMANDS;
                ds = base.ModuloDatos.ExecuteDataSet(base.Query);

                foreach (DataTable dt in ds.Tables)
                {
                    foreach (DataRow dRow in dt.Rows)
                    {
                        cmd = new UsedCommand();
                        this.FillUsedCommandsData(dRow, cmd);
                        listaComandosUsados.Add(cmd);
                    }
                }
            }
            catch (Exception ex)
            {
                listaComandosUsados.Clear();
                base.ModuloLog.Error(ex);
            }
            return listaComandosUsados;
        }
示例#9
0
        /// <summary>
        /// Método para almacenar en la base de datos el uso de comandos registrado en el fichero de logs 
        /// </summary>
        /// <param name="usedCommand"></param>
        public Boolean chargeUsedCommand(UsedCommand usedCommand)
        {
            Boolean result = false;

            //Añadimos el registro de comando usado a la lista, junto con su userId y el nombre del comando
            usedCommandsList.Add(usedCommand);

            //Como vamos a hacer carga masiva, vamos rellenando la lista hasta completarla
            if (usedCommandsList.Count >= Constantes.maxCommandsUsed)
            {
                // Cargamos los comandos utilizados en la base de datos
                result = new UsedCommandDatos().InsertUsedCommands(this.usedCommandsList);
                usedCommandsList.Clear();
            }
            else
            {
                result = true;
            }

            return result;
        }
示例#10
0
        /// <summary>
        /// Método encargado de realizar el tratamiento de los registros de los logs almacenados
        /// </summary>
        /// <param name="line"></param>
        private Boolean secondTreatFile(string line)
        {
            numLineas++;
            Boolean result = false;
            int numChar = 0;
            int userId = 0;
            int numParam = 0;
            String commandName = "";
            User usr = new User();
            Command cmd = new Command();
            UsedCommand cmd_used = new UsedCommand();

            // Cada línea del fichero contiene cuatro grupos de datos: FECHA / ID_SNOOPY / USUARIO / COMANDO
            // Jan 20 06:35:03 horus snoopy[16936]: [unknown, uid:65534 sid:16933]: sed s/\t +

            line = line.Trim();

            // En este método nos encargaremos de capturar toda la información del registro LOG almacenado
            // Fecha, ID_Snoopy, ID_Usuario, ID_Comando, Parámetros

            // FECHA                                                        // Jan 20 06:25:08 horus
            // Cogemos la fecha
            cmd_used.UsedDate = DateTime.ParseExact(line.Substring(0, 15), "MMM dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);

            // Saltamos directamente hasta el siguiente grupo de datos:
            line = line.Substring(29);

            // ID_SNOOPY                                                    // snoopy[16936]
            // Cogemos el Id_Snoopy
            numChar = line.IndexOf(']');
            cmd_used.IdSnoopy = Int32.Parse(line.Substring(0, numChar));

            // Saltamos directamente hasta el siguiente grupo de datos:

            line = line.Substring(numChar + 4);

            // USUARIO                                                      // [unknown, uid:65534 sid:16933]

            // Saltamos directamente al uid
            numChar = line.IndexOf(':') + 1;
            line = line.Substring(numChar);

            // Cogemos el UID del usuario y lo buscamos en la lista para coger el Identificador que tiene en nuestra base de datos
            numChar = line.IndexOf(' ');
            userId = Int32.Parse(line.Substring(0, numChar));

            usr = this.userList.Find(user => user.U_id == userId);
            cmd_used.User_id = usr.Id_user;

            // Saltamos directamente al último grupo de datos
            numChar = line.IndexOf(']');
            line = line.Substring(numChar + 1 + 1 +1);

            // COMANDOS                                                     // sed s/\t +

            // Cogemos el nombre del comando
            numChar = line.IndexOf(' ');

            if (numChar == -1)
            {
                commandName = this.verifyName(line);
            }
            else
            {
                commandName = this.verifyName(line.Substring(0, numChar));

                // Cogemos los parámetros
                line = line.Substring(numChar + 1);

                if (line.Length <= Constantes.maxParams)
                {
                    cmd_used.Parameters = line;
                }
                else
                {
                    cmd_used.Parameters = line.Substring(0, Constantes.maxParams);
                }

                while (line != null && line !="")
                {
                    numChar = line.IndexOf(' ');
                    if (numChar == -1)
                    {
                        numParam++;
                        line = null;
                    }
                    else
                    {
                        numParam++;
                        line = line.Substring(numChar + 1);
                    }
                }
                cmd_used.Num_params = numParam;
            }

            // Buscamos el comando en la lista para coger el Identificador que tiene en nuestra base de datos
            cmd = this.commandList.Find(command => (command.Name == commandName));

            if (cmd != null)
            {
                cmd_used.Command_id = cmd.Id_command;

                // Insertamos el registro del comando utilizado en la base de datos
                logs++;
                result = this.newData.chargeUsedCommand(cmd_used);
            }
            else
            {
                modLog.Warning("Se ha descartado el registro log almacenado en la línea " + numLineas + " del fichero de logs por NO encontrarse el comando que utiliza.");
                result = true;
            }

            return result;
        }