public static DbDataReader Select(RoleEntity role, DbConnection connection, DbTransaction transaction)
{
var reader = KandaTableDataGateway._factory.CreateReader(connection, transaction);
reader.CommandText = @"usp_SelectRoles";
KandaDbDataMapper.MapToParameters(reader, role);
return(reader.ExecuteReader());
}
/// <summary>
///
/// </summary>
/// <param name="criteria"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static KandaDbDataReader Select(MembershipsCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var reader = KandaTableDataGateway._factory.CreateReader(connection, transaction);
reader.CommandText = @"usp_SelectMemberships";
KandaDbDataMapper.MapToParameters(reader, criteria);
reader.ExecuteReader();
return(reader);
}
public static DbDataReader Select(UserAttributeEntity entity, DbConnection connection, DbTransaction transaction)
{
var reader = KandaTableDataGateway._factory.CreateReader(connection, transaction);
reader.CommandText = @"usp_SelectUserAttributes";
KandaDbDataMapper.MapToParameters(reader, entity);
reader.ExecuteReader();
return(reader);
}
public static async Task <DbDataReader> SelectAsync(MembershipsCriteria criteria, DbConnection connection, DbTransaction transaction, CancellationToken token)
{
var reader = _factory.CreateReader(connection, transaction);
reader.CommandText = @"usp_SelectMemberships";
KandaDbDataMapper.MapToParameters(reader, criteria);
var result = await reader.ExecuteReaderAsync(token);
return(reader);
}
public static async Task <int> UpdateAsync(MembershipEntity entity, DbConnection connection, DbTransaction transaction, CancellationToken token)
{
var command = _factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_UpdateMemberships";
KandaDbDataMapper.MapToParameters(command, entity);
var _ = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, null);
var affected = await command.ExecuteNonQueryAsync(token);
return(affected);
}
/// <summary>
///
/// </summary>
/// <param name="criteria"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public KandaDbDataReader Select(MembershipsCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var reader = KandaTableDataGateway._factory.CreateReader(connection, transaction);
reader.CommandText = @"usp_SelectMembershipsView";
KandaDbDataMapper.MapToParameters(reader, criteria);
var result = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.Output, DBNull.Value);
reader.Parameters.Add(result);
reader.ExecuteReader();
return(reader);
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static int Insert(MembershipRoleEntity entity, DbConnection connection, DbTransaction transaction)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertMembershipRoles";
KandaDbDataMapper.MapToParameters(command, entity);
var result = KandaTableDataGateway._factory.CreateParameter(@"Result", DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(result);
command.ExecuteNonQuery();
return((int)result.Value);
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static int Delete(MembershipUsersCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_DeleteMembershipUsers";
KandaDbDataMapper.MapToParameters(command, criteria);
var result = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(result);
command.ExecuteNonQuery();
return((int)result.Value);
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static int Insert(MembershipUserEntity entity, DbConnection connection, DbTransaction transaction)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertMembershipUsers";
KandaDbDataMapper.MapToParameters(command, entity);
var error = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(error);
var affected = command.ExecuteNonQuery();
return((int)error.Value);
}
public static int Update(UserAttributeEntity entity, DbConnection connection, DbTransaction transaction)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_UpdateUserAttributes";
KandaDbDataMapper.MapToParameters(command, entity);
var result = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(result);
command.ExecuteNonQuery();
return((int)result.Value);
}
public static bool Insert(TableEntity entity, DbConnection connection, DbTransaction transaction, out int affected)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertTable";
KandaDbDataMapper.MapToParameters(command, entity);
var error = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(error);
affected = command.ExecuteNonQuery();
entity.ID = Convert.ToInt64(command.Parameters["@identity"].Value);
return((int)error.Value == 0);
}
public void InsertMembershipsFact()
{
var connection = default(DbConnection);
var transaction = default(DbTransaction);
var command = default(DbCommand);
try
{
connection = this._factory.CreateConnection();
connection.Open();
transaction = connection.BeginTransaction(IsolationLevel.Serializable);
command = this._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertMemberships";
var entity = new MembershipEntity {
Name = new Random().Next().ToString(), Password = @"sadasfsa", CreatedOn = DateTime.Now, Enabled = true,
};
KandaDbDataMapper.MapToParameters(command, entity);
var identity = this._factory.CreateParameter("@identity", DbType.Decimal, sizeof(decimal), ParameterDirection.Output, DBNull.Value);
command.Parameters.Add(identity);
var result = this._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(result);
var affected = command.ExecuteNonQuery();
Assert.Equal(KandaTableDataGateway.NO_ERRORS, result.Value);
Assert.Equal(1, affected);
}
finally
{
if (transaction != null)
{
transaction.Rollback();
}
if (connection != null)
{
connection.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static int InsertSelect(UserHistoryEntity entity, DbConnection connection, DbTransaction transaction, out int revision)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertSelectUserHistories";
KandaDbDataMapper.MapToParameters(command, entity);
var result = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(result);
command.ExecuteNonQuery();
revision = (int)command.Parameters["@revision"].Value;
return((int)result.Value);
}
public static async Task <long> InsertAsync(MembershipEntity entity, DbConnection connection, DbTransaction transaction, CancellationToken token)
{
var command = _factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertMemberships";
KandaDbDataMapper.MapToParameters(command, entity);
var identity = KandaTableDataGateway._factory.CreateParameter(@"identity", DbType.Decimal, sizeof(decimal), ParameterDirection.Output, DBNull.Value);
command.Parameters.Add(identity);
var _ = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(_);
var affected = await command.ExecuteNonQueryAsync(token);
return(Convert.ToInt64(identity.Value));
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="password"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public MembershipUser Find(string name, string password, DbConnection connection, DbTransaction transaction)
{
var reader = default(KandaDbDataReader);
try
{
reader = MembershipsGateway.Select(name, password, connection, transaction);
var membership = (reader.Read() ? KandaDbDataMapper.MapToObject <MembershipEntity>(reader) : default(MembershipEntity));
return(new KandaMembershipUser(membership));
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="criteria"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public UserHistoryEntity Find(UserHistoriesCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var reader = default(KandaDbDataReader);
try
{
reader = UserHistoriesGateway.Select(criteria, connection, transaction);
var found = reader.Read() ? KandaDbDataMapper.MapToObject <UserHistoryEntity>(reader) : UserHistoryEntity.Empty;
return(found);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public IEnumerable <RoleAuthorizationEntity> Get(RoleAuthorizationEntity entity, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = RoleAuthorizationsGateway.Select(entity, connection, transaction);
var entities = KandaDbDataMapper.MapToEnumerable <RoleAuthorizationEntity>(reader);
return(entities);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public IEnumerable <UserAttributeHistoryEntity> Get(UserAttributeHistoryEntity entity, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = UserAttributeHistoriesGateway.Select(entity, connection, transaction);
var entities = KandaDbDataMapper.MapToEnumerable <UserAttributeHistoryEntity>(reader);
return(entities);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="criteria"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public IEnumerable <UserAttributeItemEntity> Get(UserAttributeItemsCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var reader = default(KandaDbDataReader);
try
{
reader = UserAttributeItemsGateway.Select(criteria, connection, transaction);
var gotten = KandaDbDataMapper.MapToEnumerable <UserAttributeItemEntity>(reader);
return(gotten);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IEnumerable <MembershipEntity> Get(MembershipsCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = MembershipsGateway.Select(criteria, connection, transaction);
var memberships = KandaDbDataMapper.MapToEnumerable <MembershipEntity>(reader);
return(memberships);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public MembershipEntity Find(long id, DbConnection connection, DbTransaction transaction)
{
var reader = default(KandaDbDataReader);
try
{
reader = MembershipsGateway.Select(id, connection, transaction);
if (!reader.Read())
{
return(null);
}
return(KandaDbDataMapper.MapToObject <MembershipEntity>(reader));
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public UserAttributeItemEntity Find(int id, DbConnection connection, DbTransaction transaction)
{
var reader = default(KandaDbDataReader);
try
{
reader = UserAttributeItemsGateway.Select(new UserAttributeItemsCriteria()
{
ID = id, Enabled = null,
}, connection, transaction);
var found = (reader.Read() ? KandaDbDataMapper.MapToObject <UserAttributeItemEntity>(reader) : UserAttributeItemEntity.Empty);
return(found);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static int Insert(UserEntity entity, DbConnection connection, DbTransaction transaction)
{
var command = KandaTableDataGateway._factory.CreateCommand(connection, transaction);
command.CommandText = @"usp_InsertUsers";
KandaDbDataMapper.MapToParameters(command, entity);
var identity = KandaTableDataGateway._factory.CreateParameter("@identity", DbType.Decimal, sizeof(decimal), ParameterDirection.Output, DBNull.Value);
command.Parameters.Add(identity);
var result = KandaTableDataGateway._factory.CreateParameter(KandaTableDataGateway.RETURN_VALUE, DbType.Int32, sizeof(int), ParameterDirection.ReturnValue, DBNull.Value);
command.Parameters.Add(result);
var affected = command.ExecuteNonQuery();
entity.ID = Convert.ToInt64(identity.Value);
return((int)result.Value);
}
/// <summary>
///
/// </summary>
/// <param name="criteria"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public MembershipEntity Find(MembershipsCriteria criteria, DbConnection connection, DbTransaction transaction)
{
var password = criteria.Password;
if (password == null)
{
this.DoNothing();
}
else
{
if (criteria.Password is SecureString)
{
password = ((SecureString)criteria.Password).GetString();
}
var hash = KandaHashAlgorithm.ComputeHash(typeof(SHA512Managed).FullName, (string)password, Encoding.Unicode);
password = hash;
}
criteria.Password = password;
var reader = default(KandaDbDataReader);
try
{
reader = MembershipsGateway.Select(criteria, connection, transaction);
var found = (reader.Read() ? KandaDbDataMapper.MapToObject <MembershipEntity>(reader) : MembershipEntity.Empty);
return(found);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public UserEntity Find(long id, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = UsersGateway.Select(new UsersCriteria()
{
ID = id, Enabled = true,
}, connection, transaction);
var found = (reader.Read() ? KandaDbDataMapper.MapToObject <UserEntity>(reader) : new UserEntity());
return(found);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="userId"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public IEnumerable <UserAttributeEntity> Get(long userId, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = UserAttributesGateway.Select(new UserAttributeEntity()
{
UserID = userId,
}, connection, transaction);
var attribtues = KandaDbDataMapper.MapToEnumerable <UserAttributeEntity>(reader);
return(attribtues);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public AuthorizationEntity Find(long id, DbConnection connection, DbTransaction transaction)
{
var reader = default(KandaDbDataReader);
try
{
reader = AuthorizationsGateway.Select(new AuthorizationsCriteria()
{
ID = id,
}, connection, transaction);
var found = KandaDbDataMapper.MapToObject <AuthorizationEntity>(reader);
return(found);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
public RoleEntity Find(long id, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = RolesGateway.Select(new RoleEntity()
{
ID = id,
}, connection, transaction);
var role = (reader.Read() ? KandaDbDataMapper.MapToObject <RoleEntity>(reader) : default(RoleEntity));
return(role);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="userId"></param>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public IEnumerable <UserHistoryEntity> Get(long userId, DbConnection connection, DbTransaction transaction)
{
var reader = default(DbDataReader);
try
{
reader = UserHistoriesGateway.Select(new UserHistoriesCriteria()
{
UserID = userId,
}, connection, transaction);
var entities = KandaDbDataMapper.MapToEnumerable <UserHistoryEntity>(reader);
return(entities);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}