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)); }