/// <summary>
/// Genera una lista de conexiones bien formadas dado un dataReader con conexiones
/// y un usuario.
/// </summary>
/// <param name="lector">DataReader con los datos de las conexiones.</param>
/// <param name="usuario">Usuario propietario de esas conexiones.</param>
/// <returns>Una lista de las conexiones pertenecientes al usuario.</returns>
public static List <Conexion> ExtraerConexiones(SqlDataReader lector, Usuario usuario)
{
// SELECT id_conexion, id_tipo_conexion, nombre, direccion, puerto, usuario, contrasenia
List <Conexion> conexiones = new List <Conexion>();
while (lector.Read())
{
int id_conexion = (int)lector[0];
TipoConexion tipo = (TipoConexion)(int)lector[1];
string nombreCon = (string)lector[2];
string direccion = (string)lector[3];
int puerto = (int)lector[4];
string nombreUsuario = (string)lector[5];
string contraseniaUsuario = (string)lector[6];
Conexion c = new Conexion()
{
ID = id_conexion,
TipoActual = tipo,
Nombre = nombreCon,
Direccion = direccion,
Puerto = puerto,
UsuarioConexion = nombreUsuario,
ContraseniaConexion = contraseniaUsuario,
Propietario = usuario
};
conexiones.Add(c);
}
return(conexiones);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="id_vuelo_1">Número de vuelo inicial</param>
/// <param name="id_vuelo_2">Número de vuelo final</param>
/// <param name="tipo">Tipo de conexión</param>
/// <param name="paxs_prom">Promedio de pajeros en conexión</param>
/// <param name="pax_desvest">Desviación estándar de pasajeros en conexión</param>
public ConexionPasajeros(string id_vuelo_1, string id_vuelo_2, TipoConexion tipo, double paxs_prom, double pax_desvest)
: base(id_vuelo_1, id_vuelo_2, tipo)
{
this._pax_desvest = pax_desvest;
this._paxs_promedio = paxs_prom;
Serial++;
_rdm = new Random();
}
public void comenzarTransaccion()
{
conectar();
transaccion = conexion.BeginTransaction();
estadoTransaccion = EstadoTransaccion.exito;
tipo = TipoConexion.transaccion;
this.resultado = "";
}
public void beginTransaction()
{
tipoConexion = TipoConexion.transaccion;
resultadoTransaccion = ResultadoTransaccion.exito;
cnn.ConnectionString = string_conexion;
cnn.Open();
t = cnn.BeginTransaction();
cmd.Connection = cnn;
}
/// <summary>
/// Método static que establece los valores de la cadena de conexión a la B.D. SQL para una conexión manual.
/// Es un método de la clase 'Entidad' porque es static, y por lo tanto es común a todas las clases
/// derivadas de 'Entidad'.
/// </summary>
/// <param name="_dataSource">Dirección ip del servidor SQL\Nombre estancia SQL.</param>
/// <param name="_initialCatalog">Nombre de la Base de Datos en el servidor.</param>
/// <param name="_userID">Nombre de usuario para establecer la conexión.</param>
/// <param name="_password">Password del usuario para establecer la conexión.</param>
public static void ConfigConex(string _dataSource, string _initialCatalog, string _userID, string _password)
{
dataSource = _dataSource;
initialCatalog = _initialCatalog;
userID = _userID;
password = _password;
tipoConex = TipoConexion.Manual;
}
public void conectarTransaccion()
{
conexion.ConnectionString = cadConexion;
conexion.Open();
miTipo = TipoConexion.transaccion;
transaccion = conexion.BeginTransaction();
comando.Transaction = transaccion;
miEstado = EstadoTransaccion.exito;
comando.Connection = conexion;
}
public static string StringConexion(TipoConexion t)
{
switch (t)
{
case TipoConexion.Sqlite:
return(ConfigurationManager.ConnectionStrings["Sqlite"].ConnectionString);
default:
throw new ArgumentException("Tipo de conexion no valida");
}
}
public static void InicializarConexion(TipoConexion t)
{
switch (t)
{
case TipoConexion.Sqlite:
conexion = new SqliteConexion();
break;
default:
throw new ArgumentException("Tipo de conexion no valida");
}
}
public DBHelper()
{
conexion = new SqlConnection();
//string nombreBD = ConfigurationManager.AppSettings["dbName"];
//string cadenaConexion = ConfigurationManager.ConnectionStrings[nombreBD].ConnectionString;
string cadenaConexion = new CadenaConexion().benja;
conexion.ConnectionString = cadenaConexion;
tipo = TipoConexion.comun;
resultado = "";
}
private DBConexion()
{
string_conexion = "Data Source=DESKTOP-BF1D9SV\\SQLEXPRESS;Initial Catalog=biblioteca1;Integrated Security=True";
//"Data Source=DESKTOP-IQCE3H1\\SQLEXPRESS;Initial Catalog=biblioteca2;Integrated Security=True";
//"Data Source=MONEF;Initial Catalog=biblioteca;Integrated Security=True";
//"Data Source=MONEF;Initial Catalog=biblioteca;Integrated Security=True";
//"Data Source=DESKTOP-IQCE3H1\\SQLEXPRESS;Initial Catalog=biblioteca;Integrated Security=True";
//"Data Source=maquis;Initial Catalog=biblioteca_v1;User ID=avisuales1;Password=avisuales1";
cnn = new SqlConnection();
cmd = new SqlCommand();
resultadoTransaccion = ResultadoTransaccion.exito;
tipoConexion = TipoConexion.simple;
}
/// <summary>
/// Constructor con los parámetros necesarios para guardar una conexión en BBDD con contraseña
/// </summary>
public Conexion(string nombre, string direccion, int puerto, string usuario, string contrasenia,
TipoConexion tipo, Usuario propietario, bool ssl)
{
// Campos obligatorios: nombre conexión, dirección, usuario, tipo conexión, puerto.
// De la bbdd hay que traer el ID y el puerto.
Nombre = nombre;
Direccion = direccion;
UsuarioConexion = usuario;
ContraseniaConexion = contrasenia;
TipoActual = tipo;
Propietario = propietario;
Puerto = puerto;
SSL = ssl;
}
public void desconectar()
{
if (miTipo == TipoConexion.transaccion)
{
if (miEstado == EstadoTransaccion.exito)
{
transaccion.Commit();
}
else
{
transaccion.Rollback();
}
}
conexion.Close();
miTipo = TipoConexion.comun;
}
//-----------------------------------------FIN DE LA TRANSACCION-----------------------------------------
public EstadoTransaccion CerrarTransaccion()
{
if (ControlConexion == TipoConexion.transaccional) //¿la coneccion es transaccional?
{
if (ControlTransaccion == EstadoTransaccion.correcta) //¿la transaccion es correcta sin errores?
{
Transaccion.Commit(); //finaliza y guarda
}
else
{
Transaccion.Rollback(); //finaliza y borra todos los cambios realizados
}
ControlConexion = TipoConexion.simple;
Desconectar();
}
return(ControlTransaccion);
}
public void conectar()
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
this.resultado = "";
transaccion = null;
tipo = TipoConexion.comun;
}
catch (SqlException ex)
{
throw (ex);
}
}
/// <summary>
/// Indica si una conexión cumple con ser de cierto tipo y tener cierto un número de vuelo
/// al inicio o al final de la conexión.
/// </summary>
/// <param name="num_tramo_global">Número de vuelo buscado</param>
/// <param name="tipoConexion">Tipo de conexión</param>
/// <param name="segundoTramo">True si se busca en el tramo final de la conexión</param>
/// <returns></returns>
internal bool ConexionCumpleCondicion(int num_tramo_global, TipoConexion tipoConexion, bool segundoTramo)
{
if (this.ConexionBase.Tipo == tipoConexion)
{
if (segundoTramo)
{
if (this.NumTramoFin == num_tramo_global)
{
return(true);
}
}
else
{
if (this.NumTramoIni == num_tramo_global)
{
return(true);
}
}
}
return(false);
}
//Este metodo sirve para cerrar la conexion con la BD, ya sea una transaccion o una conexion simple.
public void CloseConnection()
{
if (tipoConexion == TipoConexion.transaccion)
{
if (resultadoTransaccion == ResultadoTransaccion.exito)
{
t.Commit();
Console.WriteLine("La transaccion se realizo con exito...");
}
else
{
t.Rollback();
Console.WriteLine("La transaccion no pudo realizarse...");
}
}
tipoConexion = TipoConexion.simple;
if (cnn.State == ConnectionState.Open)
{
cnn.Close();
cnn.Dispose();
}
}
////public static void InicializarWebConfig()
////{
//// strConn = LeerParametrosWebConfig(STR_CONN);
//// provider = LeerParametrosWebConfig(PROVIDER);
//// tipoConn = int.Parse (LeerParametrosWebConfig(TIPO_CNX));
////}
//public static string LeerParametrosWebConfig(string clave)
//{
// return System.Configuration.ConfigurationManager.AppSettings[clave].ToString();
//}
public void CargarDatosConfiguracion(TipoConexion tipoConexion, string baseDatos, string dataSource, string userId, string password, string dbLocale, string clientLocale)
{
Encriptacion.Encrypt oEncrypt = new Encriptacion.Encrypt();
string claveDesencriptada = oEncrypt.DesencriptarCadena(password);
string procInversion = oEncrypt.EncriptarCadena("P@ssw0rd");
string procInversion2 = oEncrypt.EncriptarCadena("caparu2008");
tipoConn = (int)tipoConexion;
switch (tipoConexion)
{
case TipoConexion.Informix:
strConn = "Provider=Ifxoledbc.2;Persist Security Info=True;Data Source=" + dataSource + ";User ID=" + userId + ";Password="******";DB_Locale=" + dbLocale + ";Client_Locale=" + clientLocale + ";";
break;
case TipoConexion.SQLServer:
strConn = "Provider=SQLOLEDB;Data Source=" + dataSource + ";Initial Catalog=" + baseDatos + ";User Id=" + userId + ";Password="******";";
break;
default:
break;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="id_vuelo_1">Número de vuelo inicial</param>
/// <param name="id_vuelo_2">Número de vuelo final</param>
/// <param name="tipo">Tipo de conexión</param>
public ConexionPairing(string id_vuelo_1, string id_vuelo_2, TipoConexion tipo)
: base(id_vuelo_1, id_vuelo_2, tipo)
{
_aplica_dia_semana = new Dictionary <DayOfWeek, bool>();
Serial++;
}
/// <summary>
/// Método static que establece una conexión a la B.D. por medio de una cadena de conexión que está en el archivo de configuración
/// de la Aplicación.
/// Es un método de la clase 'Entidad' porque es static, y por lo tanto es común a todas las clases
/// derivadas de 'Entidad'.
/// </summary>
/// <param name="_nombreConnectionStringWebConfig">Nombre del campo 'ConnectionStrings' del archivo de configuración que
/// contiene la cadena de conexión a la B.D.</param>
public static void ConfigConex(string _nombreConnectionStringWebConfig)
{
nombreConnectionStringWebConfig = _nombreConnectionStringWebConfig;
tipoConex = TipoConexion.ArchivoConfiguracion;
}
/// <summary>
/// Método static que establece que la conexión de todas las clases 'Entidades' con el servidor SQL
/// se realizará por medio de la información descrita en un archivo de configuración de aplicaciones o
/// por medio del valor que se le asignen a las variables de conexión con el método
/// ConfigConex(dataSource,initialCatalog,userID,password).
/// <param name="_tipoConexion">
/// Manual.- Se toma el valor de la variables de conexión que tiene la clase 'Entidad'. Se modifican dichas
/// variables con la otra sobrecarga de este método.
/// ArchivoConfiguracion.- Se toma el valor para la cadena de conexión de un arhivo de configuración de aplicación
/// que contenga la línea 'name="conex"' dentro de la etiqueta 'connectionStrings'.
/// </param>
///
/// </summary>
public static void ConfigConex(TipoConexion _tipoConexion)
{
tipoConex = _tipoConexion;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="id_vuelo_1">Id de vuelo inicial</param>
/// <param name="id_vuelo_2">Id de vuelo final</param>
/// <param name="tipo">Tipo de conexión</param>
public Conexion(string id_vuelo_1, string id_vuelo_2, TipoConexion tipo)
{
this._id_vuelo_1 = id_vuelo_1;
this._id_vuelo_2 = id_vuelo_2;
this._tipo = tipo;
}
/// <summary>
/// Constructor con los parámetros necesarios para guardar una conexión en BBDD
/// </summary>
public Conexion(string nombre, string direccion, int puerto, string usuario, TipoConexion tipo, Usuario propietario)
: this(nombre, direccion, puerto, usuario, "", tipo, propietario, false)
{
}
string Cadena_Conexion = "Data Source=DESKTOP-LBDC65G;Initial Catalog=TuLuz;Integrated Security=True"; // CONEXION PEDRO
//-----------------------------------------INICIAR TRANSACCION-----------------------------------------
public void IniciarTransaccion()
{
ControlConexion = TipoConexion.transaccional;
ControlTransaccion = EstadoTransaccion.correcta;
}
