public void IsInTransactionIsTrueBecauseStartTransactionHasBeenCalled()
{
_transactionalMock.Expect("BeginTransaction");
_session.BeginTransaction();
Assert.IsTrue(_session.IsInTransaction);
_transactionalMock.Verify();
}
/// <summary>
/// Delete provided team
/// </summary>
/// <param name="entity">Team</param>
/// <returns>Returns list of validations</returns>
public async Task <IList <ValidationResult> > DeleteRole(Role entity, string userId)
{
//Validazione argomenti
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Se l'oggetto � esistente, eccezione
if (string.IsNullOrEmpty(entity.Id))
{
throw new InvalidProgramException("Provided role doesn't have valid Id");
}
var validations = new List <ValidationResult>();
//Check permissions
if (!await ValidateUserPermissions(userId, Permissions.ManagePermissions))
{
validations.AddMessage($"User {userId} has no permissions on {nameof(DeleteRole)} with Id: {entity.Id}");
return(validations);
}
//Esecuzione in transazione
using var t = DataSession.BeginTransaction();
//Eliminazione
_roleRepository.Delete(entity);
t.Commit();
return(validations);
}
/// <summary>
/// Updates provided shooter
/// </summary>
/// <param name="entity">Shooter</param>
/// <returns>Returns list of validations</returns>
public async Task <IList <ValidationResult> > UpdateRole(Role entity, string userId)
{
//Validazione argomenti
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Se l'oggetto � nuovo, eccezione
if (string.IsNullOrEmpty(entity.Id))
{
throw new InvalidProgramException("Provided user is new. Use 'CreateUser'");
}
IList <ValidationResult> validations = new List <ValidationResult>();
//Check permissions
if (!await ValidateUserPermissions(userId, Permissions.ManagePermissions))
{
validations.AddMessage($"User {userId} has no permissions on {nameof(UpdateRole)} with Id: {entity.Id}");
return(validations);
}
// controllo singolatità emplyee
validations = CheckRoleValidation(entity);
if (validations.Count > 0)
{
return(validations);
}
//Compensazione: se non ho la data di creazione, metto una data fittizia
if (entity.CreationDateTime < new DateTime(2000, 1, 1))
{
entity.CreationDateTime = new DateTime(2000, 1, 1);
}
//Esecuzione in transazione
using var t = DataSession.BeginTransaction();
//Validazione argomenti
validations = _roleRepository.Validate(entity);
//Se ho validazioni fallite, esco
if (validations.Count > 0)
{
//Rollback ed uscita
t.Rollback();
return(validations);
}
//Salvataggio
_roleRepository.Save(entity);
t.Commit();
return(validations);
}
/// <summary>
/// Fetch list of refresh tokens on platform
/// </summary>
/// <returns>Returns list of refresh tokens</returns>
public IList <RefreshToken> FetchRefreshTokens()
{
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
var result = _RefreshTokenRepository.Fetch();
t.Commit();
return(result);
}
}
/// <summary>
/// Fetch list of all users
/// </summary>
/// <returns></returns>
public IList <User> FetchAllUsers()
{
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
var result = _UserRepository.Fetch();
t.Commit();
return(result);
}
}
/// <summary>
/// Create provided shooter
/// </summary>
/// <param name="entity">Shooter</param>
/// <returns>Returns list of validations</returns>
public async Task <IList <ValidationResult> > CreateRole(Role entity, string userId)
{
//Validazione argomenti
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Se l'oggetto � esistente, eccezione
if (!string.IsNullOrEmpty(entity.Id))
{
throw new InvalidProgramException("Provided Shooter seems to already existing");
}
//Predisposizione al fallimento
IList <ValidationResult> validations = new List <ValidationResult>();
//Check permissions
if (!await ValidateUserPermissions(userId, Permissions.ManagePermissions))
{
validations.AddMessage($"User {userId} has no permissions on {nameof(CreateRole)}");
return(validations);
}
// controllo singolatità emplyee
validations = CheckRoleValidation(entity);
if (validations.Count > 0)
{
return(validations);
}
// Settaggio data di creazione
entity.CreationDateTime = DateTime.UtcNow;
//Esecuzione in transazione
using var t = DataSession.BeginTransaction();
//Validazione argomenti
validations = _roleRepository.Validate(entity);
//Se ho validazioni fallite, esco
if (validations.Count > 0)
{
//Rollback ed uscita
t.Rollback();
return(validations);
}
//Salvataggio
_roleRepository.Save(entity);
t.Commit();
return(validations);
}
/// <summary>
/// Update user instagram access token
/// </summary>
/// <param name="entity">user entity</param>
/// <param name="userRoleKey">user role key</param>
/// <returns>User Entity</returns>
public IList <ValidationResult> UpdateUser(Shooter entity)
{
//Validazione argomenti
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Se l'oggetto è nuovo, eccezione
if (string.IsNullOrEmpty(entity.Id))
{
throw new InvalidProgramException("Provided user is new. Operation aborted");
}
// controllo validazione user
var validations = CheckUserValidation(entity);
if (validations.Count > 0)
{
return(validations);
}
//Esecuzione in transazione
using var t = DataSession.BeginTransaction();
//Validazione argomenti
validations = _userRepository.Validate(entity);
//Se ho validazioni fallite, esco
if (validations.Count > 0)
{
//Rollback ed uscita
t.Rollback();
return(validations);
}
//Salvataggio
validations = SaveEntity(entity, _userRepository);
//Se ho validazioni fallite, esco
if (validations.Count > 0)
{
//Rollback ed uscita
t.Rollback();
return(validations);
}
t.Commit();
return(validations);
}
/// <summary>
/// Deletes single refresh token
/// </summary>
/// <param name="entity">Token to delete</param>
public void DeleteRefreshToken(RefreshToken entity)
{
//Validazione argomenti
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
_RefreshTokenRepository.Delete(entity);
t.Commit();
}
}
/// <summary>
/// Get single refresh token using provided token
/// </summary>
/// <param name="tokenHash">Refresh token</param>
/// <returns>Returns entity of null</returns>
public RefreshToken GetRefreshToken(string tokenHash)
{
//Validazione argomenti
if (string.IsNullOrEmpty(tokenHash))
{
throw new ArgumentNullException(nameof(tokenHash));
}
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
var result = _RefreshTokenRepository.GetSingle(a => a.TokenHash == tokenHash);
t.Commit();
return(result);
}
}
/// <summary>
/// Get single audience by client id
/// </summary>
/// <param name="clientId">Client id</param>
/// <returns>Returns audience or null</returns>
public Audience GetAudienceByClientId(string clientId)
{
//Validazione argomenti
if (string.IsNullOrEmpty(clientId))
{
throw new ArgumentNullException(nameof(clientId));
}
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
var result = _AudienceRepository.GetSingle(a => a.ClientId == clientId);
t.Commit();
return(result);
}
}
/// <summary>
/// Get single user by user name
/// </summary>
/// <param name="userName">User name</param>
/// <returns>Returns user or null</returns>
public User GetUserByUserName(string userName)
{
//Validazione argomenti
if (string.IsNullOrEmpty(userName))
{
throw new ArgumentNullException(nameof(userName));
}
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
var result = _UserRepository.GetUserByUserName(userName);
t.Commit();
return(result);
}
}
/// <summary>
/// Delete provided team
/// </summary>
/// <param name="entity">Team</param>
/// <returns>Returns list of validations</returns>
public async Task <IList <ValidationResult> > CreateUserRole(UserRole entity, string userId)
{
//Validazione argomenti
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Se l'oggetto � esistente, eccezione
if (!string.IsNullOrEmpty(entity.Id))
{
throw new InvalidProgramException("Provided user role seems to already existing");
}
IList <ValidationResult> validations = new List <ValidationResult>();
//Check permissions
if (!await ValidateUserPermissions(userId, Permissions.ManagePermissions))
{
validations.AddMessage($"User {userId} has no permissions on {nameof(CreateUserRole)} with Id: {entity.Id}");
return(validations);
}
// Settaggio data di creazione
entity.CreationDateTime = DateTime.UtcNow;
//Esecuzione in transazione
using var t = DataSession.BeginTransaction();
validations = _userRoleRepository.Validate(entity);
if (validations.Count > 0)
{
t.Rollback();
return(validations);
}
//Salvataggio
_userRoleRepository.Save(entity);
t.Commit();
_cache.RemoveValue($"perm:{userId}");
return(validations);
}
public IList <ValidationResult> SyncPasswords()
{
var shooters = this._userRepository.Fetch(x => string.IsNullOrEmpty(x.Password));
IList <ValidationResult> validations = new List <ValidationResult>();
var t = DataSession.BeginTransaction();
foreach (var shooter in shooters)
{
if (string.IsNullOrEmpty(shooter.Username))
{
shooter.Password = shooter.FirstName + shooter.LastName;
}
if (string.IsNullOrEmpty(shooter.Email))
{
shooter.Email = $"{shooter.FirstName}{shooter.LastName}@email.com".ToLower();
}
shooter.Password = shooter.FirstName + shooter.LastName;
//Validazione argomenti
validations = _userRepository.Validate(shooter);
//Se ho validazioni fallite, esco
if (validations.Count > 0)
{
//Rollback ed uscita
t.Rollback();
return(validations);
}
//Salvataggio
_userRepository.Save(shooter);
}
t.Commit();
return(validations);
}
/// <summary>
/// Get refresh token using user and audience
/// </summary>
/// <param name="user">User</param>
/// <param name="audience">Audience</param>
/// <returns>Returns refresh token or null</returns>
private RefreshToken GetRefreshToken(User user, Audience audience)
{
//Validazione argomenti
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (audience == null)
{
throw new ArgumentNullException(nameof(audience));
}
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Estrazione dati e commit
var result = _RefreshTokenRepository.GetSingle(a =>
a.UserName == user.UserName && a.ClientId == audience.ClientId);
t.Commit();
return(result);
}
}
public void ProcedureExecuteTransaction()
{
var session = new DataSession("AspNet").Log(Console.WriteLine);
session.Should().NotBeNull();
var transaction = session.BeginTransaction(IsolationLevel.Unspecified);
transaction.Should().NotBeNull();
Guid userId = Guid.Empty;
int errorCode = -1;
var username = "******" + DateTime.Now.Ticks;
var email = username + "@email.com";
var result = session.StoredProcedure("[dbo].[aspnet_Membership_CreateUser]")
.Parameter("@ApplicationName", "/")
.Parameter("@UserName", username)
.Parameter("@Password", "T@est" + DateTime.Now.Ticks)
.Parameter("@Email", email)
.Parameter("@PasswordSalt", "test salt")
.Parameter <string>("@PasswordQuestion", null)
.Parameter <string>("@PasswordAnswer", null)
.Parameter("@IsApproved", true)
.Parameter("@CurrentTimeUtc", DateTime.UtcNow)
.Parameter("@UniqueEmail", 1)
.Parameter("@PasswordFormat", 1)
.ParameterOut <Guid>("@UserId", p => userId = p)
.Return <int>(p => errorCode = p)
.Execute();
result.Should().BeGreaterOrEqualTo(1);
userId.Should().NotBe(Guid.Empty);
errorCode.Should().Be(0);
transaction.Commit();
}
/// <summary>
/// Check user password
/// </summary>
/// <param name="user">User</param>
/// <param name="newPassword">New password</param>
/// <returns>Returns signed in user or null</returns>
public IList <ValidationResult> UpdateUserPassword(Shooter user, string newPassword)
{
//Validazione argomenti
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrEmpty(newPassword))
{
throw new ArgumentNullException(nameof(newPassword));
}
//aggiorno la password
user.Password = _identityClient.EncryptPassword(newPassword);
IList <ValidationResult> validations = new List <ValidationResult>();
//Esecuzione in transazione
using (var t = DataSession.BeginTransaction())
{
//Validazione argomenti
validations = _userRepository.Validate(user);
//Se ho validazioni fallite, esco
if (validations.Count > 0)
{
//Rollback ed uscita
t.Rollback();
return(validations);
}
//Salvataggio
_userRepository.Save(user);
t.Commit();
}
return(validations);
}
public void ProcedureExecuteTransaction()
{
var session = new DataSession("AspNet").Log(Console.WriteLine);
session.Should().NotBeNull();
var transaction = session.BeginTransaction(IsolationLevel.Unspecified);
transaction.Should().NotBeNull();
Guid userId = Guid.Empty;
int errorCode = -1;
var username = "******" + DateTime.Now.Ticks;
var email = username + "@email.com";
var result = session.StoredProcedure("[dbo].[aspnet_Membership_CreateUser]")
.Parameter("@ApplicationName", "/")
.Parameter("@UserName", username)
.Parameter("@Password", "T@est" + DateTime.Now.Ticks)
.Parameter("@Email", email)
.Parameter("@PasswordSalt", "test salt")
.Parameter<string>("@PasswordQuestion", null)
.Parameter<string>("@PasswordAnswer", null)
.Parameter("@IsApproved", true)
.Parameter("@CurrentTimeUtc", DateTime.UtcNow)
.Parameter("@UniqueEmail", 1)
.Parameter("@PasswordFormat", 1)
.ParameterOut<Guid>("@UserId", p => userId = p)
.Return<int>(p => errorCode = p)
.Execute();
result.Should().BeGreaterOrEqualTo(1);
userId.Should().NotBe(Guid.Empty);
errorCode.Should().Be(0);
transaction.Commit();
}
