public static object ExecuteScalar(this IngresConnection conn, string sql, IngresTransaction tx = null)
{
var cmd = tx == null ? new IngresCommand(sql, conn) : new IngresCommand(sql, conn, tx);
using (cmd)
return(cmd.ExecuteScalar());
}
private void Delete_Click(object sender, EventArgs e)
{
IngresConnection con = new IngresConnection(Login.myConnectionString);
con.Open();
IngresCommand cmd = new IngresCommand();
cmd.Connection = con;
cmd.CommandText = "rol_delete";
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.Add(new IngresParameter("t_id_rol", IngresType.Decimal));
cmd.Parameters["t_id_rol"].Value = int.Parse(this.metroTextBox1.Text);
IngresTransaction trans = con.BeginTransaction();
cmd.Transaction = trans;
try
{
cmd.ExecuteNonQuery();
trans.Commit();
MetroMessageBox.Show(this, "Elemento eliminado correctamente.", "Nota", MessageBoxButtons.OK, MessageBoxIcon.Question);
}
catch (IngresException c)
{
MetroMessageBox.Show(this, c.ErrorCode + c.Message, "Error");
}
con.Close();
this.read();
}
/// <summary>
/// Gets the Id for the current application.
/// </summary>
/// <param name="conn">The Ingres connection to use.</param>
/// <param name="tran">The Ingres transaction to use.</param>
/// <returns>The Id for the current application.</returns>
private string GetApplicationId(IngresConnection conn, IngresTransaction tran)
{
string id = null;
string sql = @"
SELECT
ApplicationId
FROM
aspnet_Applications
WHERE LoweredApplicationName = ?
";
// Create the new command and enrol in the current transaction
IngresCommand cmd = new IngresCommand(sql, this.conn);
cmd.Transaction = this.tran;
cmd.Parameters.Add("LoweredApplicationName", DbType.String).Value = this.config.ApplicationName.ToLower();
conn.Open();
IngresDataReader reader = cmd.ExecuteReader();
if (reader != null)
{
if (reader.HasRows)
{
reader.Read();
// Retrieve the Id
id = DBUtil.ColValAsString(reader, "ApplicationId");
reader.Close();
}
else
{
// Close the reader.
reader.Close();
// We don't have an application so create one.
this.CreateApplication(this.config.ApplicationName, out id);
}
}
// Mark the application Id as current so that we don't have to fetch it from the database
// again unless it changes.
this.config.IsApplicationIdCurrent = true;
// Close the connection
conn.Close();
return(id);
}
/// <summary>
/// Initializes a new instance of the IngresRoleProviderHandler class.
/// </summary>
/// <param name="conn">The Ingres connection to use.</param>
/// <param name="tran">The Ingres transaction to use.</param>
/// <param name="config">The configuration settings to use.</param>
/// <param name="provider">The Ingres Role Provider facade to use.</param>
internal IngresRoleProviderHandler(IngresConnection conn, IngresTransaction tran, IngresRoleProviderConfiguration config, IngresRoleProvider provider)
{
if (conn == null || tran == null)
{
throw new Exception();
}
this.tran = tran;
this.conn = conn;
this.config = config;
this.provider = provider;
}
/// <summary>
/// This method takes a role name and determines whether the role exists.
/// </summary>
/// <remarks>
/// This method overrides a method from the <c>System.Web.Security.RoleProvider</c> class to provide an Ingres
/// specific implementation.
/// </remarks>
/// <param name="roleName">Role name to check the existence of.</param>
/// <returns>Whether the given role exists.</returns>
public override bool RoleExists(string roleName)
{
bool result = false;
IngresTransaction tran = null;
try
{
using (IngresConnection conn = new IngresConnection(this.config.ConnectionString))
{
// Open the connection and start a new transaction
conn.Open();
tran = conn.BeginTransaction();
// Call the implementation of the method
result = this.GetHandler(conn, tran).RoleExists(roleName);
// Commit the transaction
tran.Commit();
}
}
catch (Exception ex)
{
// Attempt to rollback
try
{
if (tran != null && tran.Connection != null)
{
tran.Rollback();
}
}
catch
{
// Add the rollback error.
ExceptionHandler.LogRollbackWarning(RoleProviderMethod.RoleExists);
}
// Handle the exception appropriately
ExceptionHandler.HandleException(ex, RoleProviderMethod.RoleExists);
}
return(result);
}
/// <summary>
/// Takes an array of user names and an array of role names and removes the specified users
/// from the specified roles.
/// </summary>
/// <remarks>
/// <para>
/// <c>RemoveUsersFromRoles</c> throws a <c>ProviderException</c> if any of the users or roles do not
/// exist, or if any user specified in the call does not belong to the role from which he
/// or she is being removed.
/// </para>
/// <para>
/// This method overrides a method from the <c>System.Web.Security.RoleProvider</c> class to provide an Ingres
/// specific implementation.
/// </para>
/// </remarks>
/// <param name="usernames">The array of usernames.</param>
/// <param name="roleNames">The array of roles.</param>
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
IngresTransaction tran = null;
try
{
using (IngresConnection conn = new IngresConnection(this.config.ConnectionString))
{
// Open the connection and start a new transaction
conn.Open();
tran = conn.BeginTransaction();
// Call the implementation of the method
this.GetHandler(conn, tran).RemoveUsersFromRoles(usernames, roleNames);
// Commit the transaction
tran.Commit();
}
}
catch (Exception ex)
{
// Attempt to rollback
try
{
if (tran != null && tran.Connection != null)
{
tran.Rollback();
}
}
catch
{
// Add the rollback error.
ExceptionHandler.LogRollbackWarning(RoleProviderMethod.RemoveUsersFromRoles);
}
// Handle the exception appropriately
ExceptionHandler.HandleException(ex, RoleProviderMethod.RemoveUsersFromRoles);
}
}
/// <summary>
/// Gets a handler for the Ingres membership provider.
/// </summary>
/// <param name="conn">The Ingres connection.</param>
/// <param name="tran">The Ingres transaction to use.</param>
/// <returns>The handler</returns>
private IngresRoleProviderHandler GetHandler(IngresConnection conn, IngresTransaction tran)
{
IngresRoleProviderHandler handler = new IngresRoleProviderHandler(conn, tran, this.config, this);
return(handler);
}
public static async Task <object> ExecuteScalarAsync(this IngresConnection conn, string sql, IngresTransaction tx = null)
{
var cmd = tx == null ? new IngresCommand(sql, conn) : new IngresCommand(sql, conn, tx);
using (cmd)
return(await cmd.ExecuteScalarAsync());
}
/// <summary>
/// Creates a role in the database.
/// </summary>
/// <param name="roleName">The rolename to create.</param>
/// <param name="roleid">The role id.</param>
/// <param name="conn">The Ingres connection to use.</param>
/// <param name="tran">The Ingres transaction to use.</param>
private void CreateRole(string roleName, out string roleid, IngresConnection conn, IngresTransaction tran)
{
// Validate the roleName
ValidationUtil.CheckParameterIsOK(ref roleName, true, true, true, 256, "roleName");
// Ensure that the proposed roleName does not already exist
if (this.RoleExists(roleName))
{
throw new ProviderException(string.Format(Messages.RoleAlreadyExists, roleName));
}
string sql = @"
INSERT INTO aspnet_Roles
(ApplicationId,
RoleId,
RoleName,
LoweredRoleName,
Description)
VALUES
(?,
?,
?,
?,
NULL)
";
// Create the command with the current connection and enrol in the transaction
IngresCommand cmd = new IngresCommand(sql, this.conn);
cmd.Transaction = this.tran;
cmd.CommandTimeout = this.config.CommandTimeout;
// Generate a new role Id - this will be the sent out
roleid = Guid.NewGuid().ToString().ToLower();
// Add the required parameters
cmd.Parameters.Add("ApplicationId", DbType.String).Value = this.ApplicationId;
cmd.Parameters.Add("RoleId", DbType.String).Value = roleid;
cmd.Parameters.Add("RoleName", DbType.String).Value = roleName;
cmd.Parameters.Add("LoweredRoleName", DbType.String).Value = roleName.ToLower();
// Execute the query
int rows = cmd.ExecuteNonQuery();
// Validate that the query affected the correct numbber of rows.
if (rows != 1)
{
throw new ProviderException(string.Format(Messages.UnknownError));
}
}
