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;
}
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;
}
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();
}
}
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;
}
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;
}
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;
}
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;
}
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;
}
/// <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;
}
/// <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;
}