public ServiceResponse <UserAuthorisation> SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
var serviceResponse = new ServiceResponse <UserAuthorisation>();
try
{
if (string.IsNullOrWhiteSpace(userAuthorisation.UserName) ||
string.IsNullOrWhiteSpace(userAuthorisation.DisplayName))
{
throw new Exception("Mandatory fields: UserName, DisplayName");
}
var savedUserAuthorisation = authorisationManagerDataProxy.SaveUserAuthorisation(userAuthorisation);
serviceResponse.Payload = savedUserAuthorisation;
}
catch (Exception ex)
{
serviceResponse.IsError = true;
serviceResponse.Message = ex.Message;
logger.Log("AuthorisationManagerServer.SaveUserAuthorisation - " + ex.Message, LogCategory.Exception, LogPriority.None);
logger.Log(Serializer.SerializeToJson(userAuthorisation), LogCategory.Exception, LogPriority.None);
logger.Log(ex.StackTrace, LogCategory.Exception, LogPriority.None);
}
return(serviceResponse);
}
private async void SignIn()
{
IsWorking = true;
await Task.Run(() =>
{
UserAuthorisation userAuthorisation = new UserAuthorisation();
try
{
if (!CheckInternetConnection())
{
MessageBox.Show("No internet connection");
return;
}
if (!blockChainHandler.IsBlockChainAvailable())
{
MessageBox.Show("Blockchain unavailable");
return;
}
CurrentUserId = userAuthorisation.CreateSession(Username, Password, Role);
if (CurrentUserId != 0)
{
MainViewModel.LoginSuccessful(Username, Role);
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
});
IsWorking = false;
}
public async Task <UserAuthorisation> SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
var response = await authorisationManagerService.SaveUserAuthorisation(userAuthorisation).ConfigureAwait(false);
ServiceResponseErrorHandler(response);
return(response.Payload);
}
public async Task CanPerformActivityAsync_NoDelegateRunSynchronously_ReturnFalse()
{
// Arrange
var user = new UserAuthorisation(userName);
// Act
var result = await user.CanPerformActivityAsync("READ");
// Assert
Assert.IsFalse(result);
}
public async Task CanPerformActivityAsync_NoDelegateRunSynchronously_ReturnTrue()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var user = new UserAuthorisation(userName, new List<Role>() { dataReader });
// Act
var result = await user.CanPerformActivityAsync("READ");
// Assert
Assert.IsTrue(result);
}
public void CanPerformActivity_AddDelegate_ReturnTrue()
{
// Arrange
var user = new UserAuthorisation(userName)
.AddCanPerformActivityDelegate(CanPerformActivityHandlerReturnTrue);
// Act
var result = user.CanPerformActivity("READ");
// Assert
Assert.IsTrue(result);
}
public void CanPerformActivity_MultipleRolesMultipleActivities_ReturnFalse()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var dataWriter = roles.First(r => r.Name.Equals("Data Writer"));
var roleDataReviewer = roles.First(r => r.Name.Equals("Data Reviewer"));
var user = new UserAuthorisation(userName, new List<Role>() { dataReader, dataWriter, roleDataReviewer });
// Act
var result = user.CanPerformActivity("EDITOR");
// Assert
Assert.IsFalse(result);
}
private UserNode GetUserNode(UserAuthorisation userAuthorisation)
{
var userNode = new UserNode(userAuthorisation);
userAuthorisation.Roles.ToList().ForEach(r =>
{
var rn = GetRoleNode(r);
rn.ParentId = userAuthorisation.Id;
rn.ParentType = ParentType.UserNode;
userNode.Roles.Add(rn);
});
return(userNode);
}
public async Task CanPerformActivityAsync_PassDelegateParameter_ReturnTrue()
{
// Arrange
var mockPredicate = new Mock<Func<UserAuthorisation, string, Task<bool>>>();
mockPredicate.SetReturnsDefault(Task.FromResult(true));
var user = new UserAuthorisation(userName);
// Act
var result = await user.CanPerformActivityAsync("READ", mockPredicate.Object);
// Assert
Assert.IsTrue(result);
mockPredicate.Verify(p => p(user, "READ"), Times.Once);
}
protected override async void OnPublished(object data)
{
try
{
IsBusy = true;
currentUser = await authorisationManagerServiceManager.GetUserAuthorisation(Environment.UserName);
if (currentUser.CanPerformActivity(Permissions.AUTHORISATION_READ.ToString()))
{
IsEditable = currentUser.CanPerformActivity(Permissions.AUTHORISATION_WRITE.ToString());
var authorisationNodes = await authorisationManagerServiceManager.GetAuthorisationNodes();
Activities = new ObservableCollection <ActivityNode>(authorisationNodes.ActivityNodes);
Roles = new ObservableCollection <RoleNode>(authorisationNodes.RoleNodes);
Users = new ObservableCollection <UserNode>(authorisationNodes.UserNodes);
}
else
{
ShowMessage(new Message()
{
MessageType = MessageType.Error,
Text = "Access denied."
});
Logger.Log("ConfigurationAuthorisationViewModel OnPublished access denied.", Category.Warn, Priority.None);
}
ResetStatus();
}
catch (Exception ex)
{
ShowMessage(new Message()
{
MessageType = MessageType.Error,
Text = ex.Message
}, true);
IsBusy = false;
}
finally
{
OnPropertyChanged("");
}
Logger.Log("ConfigurationAuthorisationViewModel OnPublished complete", Category.Info, Priority.None);
}
public void CanPerformActivity_MockDelegate_ReturnTrue()
{
// Arrange
var mockCanPerformActivityHandler = new Mock<Func<UserAuthorisation,string, bool>>();
mockCanPerformActivityHandler.SetReturnsDefault(true);
var user = new UserAuthorisation(userName)
.AddCanPerformActivityDelegate(mockCanPerformActivityHandler.Object);
// Act
var result = user.CanPerformActivity("READ");
// Assert
Assert.IsTrue(result);
mockCanPerformActivityHandler.Verify(u => u(user, "READ"), Times.Once);
}
public async Task<ServiceResponse<UserAuthorisation>> SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
var client = new HttpClient();
client.BaseAddress = new Uri(baseAddress);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
HttpResponseMessage response = await client.PostAsJsonAsync("api/UserAuthorisation/SaveUserAuthorisation/", userAuthorisation);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsAsync<ServiceResponse<UserAuthorisation>>();
return content;
}
catch (Exception ex)
{
var serviceResponse = new ServiceResponse<UserAuthorisation>(ex.Message, true);
return serviceResponse;
}
}
public UserAuthorisation SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
var isInsert = userAuthorisation.Id.Equals(0);
using (var conn = new SqlConnection(ConnectionString))
{
if (isInsert)
{
userAuthorisation = conn.Insert(userAuthorisation, "Id");
}
else
{
conn.Update(userAuthorisation, new SqlParameter()
{
ParameterName = "Id", Value = userAuthorisation.Id
});
}
}
return(userAuthorisation);
}
public UserAuthorisation SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
var isInsert = userAuthorisation.Id.Equals(0);
using (var conn = new OracleConnection(ConnectionString))
{
if (isInsert)
{
userAuthorisation.Id = Convert.ToInt32(conn.ExecuteScalar("SELECT \"USERAUTHORISATION_SEQ\".NEXTVAL FROM DUAL"));
userAuthorisation = conn.Insert(userAuthorisation);
}
else
{
conn.Update(userAuthorisation,
new OracleParameter()
{
ParameterName = "Id", Value = userAuthorisation.Id
});
}
}
return(userAuthorisation);
}
public void SerializeRolesToXml_DeserializeXmlToRoles_TestPasses()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var user1 = new UserAuthorisation(userName,
new List<Role>() {dataReader});
// Act
var xml = user1.SerializeRolesToXml();
var user2 = new UserAuthorisation(userName, xml, RoleStringFormat.Xml);
// Assert
Assert.AreEqual(1, user2.Roles.Count);
Assert.IsTrue(user2.Roles[0].Name.Equals("Data Reader"));
Assert.AreEqual(1, user2.Roles[0].Activities.Count);
Assert.IsTrue(user2.Roles[0].Activities[0].Name.Equals("Read"));
Assert.AreEqual(user1.Roles.Count, user2.Roles.Count);
Assert.IsTrue(user1.Roles[0].Name.Equals(user2.Roles[0].Name));
Assert.AreEqual(user1.Roles[0].Activities.Count, user2.Roles[0].Activities.Count);
Assert.IsTrue(user1.Roles[0].Activities[0].Name.Equals(user2.Roles[0].Activities[0].Name));
}
public void IsInRole_SingleRole_ReturnTrue()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var user = new UserAuthorisation(userName, new List<Role>() { dataReader });
// Act
var result = user.IsInRole("DATAREADER");
// Assert
Assert.IsTrue(result);
}
public void IsInRole_PassMockDelegateIntoCall_ReturnTrue()
{
// Arrange
var mockIsInRoleHandler = new Mock<Func<UserAuthorisation, string, bool>>();
mockIsInRoleHandler.SetReturnsDefault(true);
var user = new UserAuthorisation(userName);
// Act
var result = user.IsInRole("DATAREADER", mockIsInRoleHandler.Object);
// Assert
Assert.IsTrue(result);
mockIsInRoleHandler.Verify(u => u(user, "DATAREADER"), Times.Once);
}
public void CanPerformActivity_NestedActivity_ReturnTrue()
{
// Arrange
var dataEditor = roles.First((r => r.Name.Equals("Data Editor")));
var user = new UserAuthorisation(userName, new List<Role>() { dataEditor });
// Act
var result = user.CanPerformActivity("EXPORT");
// Assert
Assert.IsTrue(result);
}
public UserNode(UserAuthorisation userAuthorisation)
{
UserAuthorisation = userAuthorisation;
Roles = new ObservableCollection <RoleNode>();
}
private void IntialiseUserAuthorisationAddUserNameAndRolesDelegate(UserAuthorisation userAuthorisation)
{
userAuthorisation.UserName = userName;
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
userAuthorisation.Roles.Add(dataReader);
}
public async Task <ServiceResponse <UserAuthorisation> > SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
WCFProxy.AuthorisationManagerServerClient authorisationManagerServerClient = null;
try
{
authorisationManagerServerClient
= new WCFProxy.AuthorisationManagerServerClient(new WSHttpBinding(),
new EndpointAddress(endpointAddress));
var result = await authorisationManagerServerClient.SaveUserAuthorisationAsync(userAuthorisation).ConfigureAwait(false);
authorisationManagerServerClient.Close();
return(result);
}
catch (Exception ex)
{
if (authorisationManagerServerClient != null)
{
authorisationManagerServerClient.Abort();
}
var serviceResponse = new ServiceResponse <UserAuthorisation>(ex.Message, true);
return(serviceResponse);
}
}
public void Initialise_DeserializeXmlToRolesWithEmptyString_TestPasses()
{
// Act
var user = new UserAuthorisation(userName, String.Empty, RoleStringFormat.Xml);
// Assert
Assert.IsFalse(user.Roles.Any());
}
public void CanPerformActivity_SingleRoleSingleActivity_ReturnTrue()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var user = new UserAuthorisation(userName, new List<Role>() { dataReader });
// Act
var result = user.CanPerformActivity("READ");
// Assert
Assert.IsTrue(result);
}
public void CanPerformActivity_NestedRoleNestedActivity_ReturnTrue()
{
// Arrange
var superUser = roles.First((r => r.Name.Equals("Super User")));
var user = new UserAuthorisation(userName, new List<Role>() { superUser });
// Act
var result = user.CanPerformActivity("WRITE");
// Assert
Assert.IsTrue(result);
}
public ServiceResponse <UserAuthorisation> SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
return(authorisationManagerServer.SaveUserAuthorisation(userAuthorisation));
}
private bool CanPerformActivityHandlerReturnTrue(UserAuthorisation userAuthorisation, string activityCode)
{
return true;
}
public void IsInRole_MultipleNestedDuplicateRoles_ReturnTrue()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var dataWriter = roles.First(r => r.Name.Equals("Data Writer"));
var roleDataReviewer = roles.First(r => r.Name.Equals("Data Reviewer"));
var global = roles.First(r => r.Name.Equals("Global"));
var roleDataEditor = roles.First(r => r.Name.Equals("Data Editor"));
var user = new UserAuthorisation(userName,
new List<Role>() { dataReader, dataWriter, roleDataReviewer, global, roleDataEditor });
// Act
var result = user.IsInRole("DATAWRITER");
// Assert
Assert.IsTrue(result);
}
private bool IsInRoleHandlerReturnTrue(UserAuthorisation userAuthorisation, string roleCode)
{
return true;
}
public void IsInRole_MultipleNestedRoles_ReturnFalse()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var dataWriter = roles.First(r => r.Name.Equals("Data Writer"));
var roleDataReviewer = roles.First(r => r.Name.Equals("Data Reviewer"));
var roleDataEditor = roles.First(r => r.Name.Equals("Data Editor"));
var user = new UserAuthorisation(userName,
new List<Role>() { dataReader, dataWriter, roleDataReviewer, roleDataEditor });
// Act
var result = user.IsInRole("MANAGER");
// Assert
Assert.IsFalse(result);
}
public async Task IsInRoleAsync_NoDelegateRunSynchronously_ReturnFalse()
{
// Arrange
var user = new UserAuthorisation(userName);
// Act
var result = await user.IsInRoleAsync("DATAREADER");
// Assert
Assert.IsFalse(result);
}
public void IsInRole_NestedRole_ReturnTrue()
{
// Arrange
var dataEditor = roles.First((r => r.Name.Equals("Data Editor")));
var user = new UserAuthorisation(userName, new List<Role>() { dataEditor });
// Act
var result = user.IsInRole("DATAWRITER");
// Assert
Assert.IsTrue(result);
}
public void Intialise_AddInitialisationDelegate_UserNameAndRolesAdded()
{
// Act
var user = new UserAuthorisation(IntialiseUserAuthorisationAddUserNameAndRolesDelegate);
var result = user.IsInRole("DATAREADER");
// Assert
Assert.AreEqual(user.UserName, userName);
Assert.IsTrue(result);
Assert.AreEqual(user.Roles.Count, 1);
Assert.AreEqual(user.Roles[0].Name, "Data Reader");
}
public void CanPerformActivity_MultipleRolesNestedDuplicateActivities_ReturnTrue()
{
// Arrange
var dataReader = roles.First((r => r.Name.Equals("Data Reader")));
var dataWriter = roles.First(r => r.Name.Equals("Data Writer"));
var roleDataReviewer = roles.First(r => r.Name.Equals("Data Reviewer"));
var global = roles.First(r => r.Name.Equals("Global"));
var roleDataEditor = roles.First(r => r.Name.Equals("Data Editor"));
var user = new UserAuthorisation(userName,
new List<Role>() { dataReader, dataWriter, roleDataReviewer, global, roleDataEditor });
// Act
var result = user.CanPerformActivity("SENDEMAIL");
// Assert
Assert.IsTrue(result);
}
public async Task IsInRoleAsync_AddDelegateDuringInitialisation_ReturnTrue()
{
// Arrange
var mockPredicate = new Mock<Func<UserAuthorisation, string, Task<bool>>>();
mockPredicate.SetReturnsDefault(Task.FromResult(true));
var user = new UserAuthorisation(userName)
.AddAsyncIsInRoleDelegate(mockPredicate.Object);
// Act
var result = await user.IsInRoleAsync("DATAREADER");
// Assert
Assert.IsTrue(result);
mockPredicate.Verify(p => p(user, "DATAREADER"), Times.Once);
}
public void IsInRole_AddDelegate_ReturnTrue()
{
// Arrange
var user = new UserAuthorisation(userName)
.AddIsInRoleDelegate(IsInRoleHandlerReturnTrue);
// Act
var result = user.IsInRole("DATAREADER");
// Assert
Assert.IsTrue(result);
}
public void IsInRole_MockDelegate_ReturnFalse()
{
// Arrange
var mockIsInRoleHandler = new Mock<Func<UserAuthorisation, string, bool>>();
mockIsInRoleHandler.SetReturnsDefault(false);
var user = new UserAuthorisation(userName)
.AddIsInRoleDelegate(mockIsInRoleHandler.Object);
// Act
var result = user.IsInRole("DATAREADER");
// Assert
Assert.IsFalse(result);
mockIsInRoleHandler.Verify(u => u(user, "DATAREADER"), Times.Once);
}
public UserAuthorisation SaveUserAuthorisation(UserAuthorisation userAuthorisation)
{
return(authorisationManagerServiceData.SaveUserAuthorisation(userAuthorisation));
}
