public ActionResult HomePost(IPrincipal principal) { var user = new User(); try { TryUpdateModel(user); // User name cannot have the character '-' because it is used to concatenate the user name and indentity provider in the Users table. if (user.Name.Contains("-")) { ViewBag.ValidationErrors = new List<ValidationResult> { new ValidationResult("User name cannot have the character '-'") }; return View(user); } if (user.IsValid()) { _usersService.FillAuthenticationInfo(user, principal); _usersService.Create(user); Session["CurrentUser"] = user; return RedirectToAction("Index", "TaskLists"); } else { ViewBag.ValidationErrors = user.GetValidationErrors(); } } catch (Exception ex) { ViewBag.ValidationErrors = new List<ValidationResult> { new ValidationResult(string.Format("User creation exception: {0}", ex.Message)) }; } return View(user); }
public Note(string title, string content, User owner, TaskList containerList) : this() { Title = title; Content = content; Owner = owner; Container = containerList; }
public void ANoteWithAnEmptyTittleIsInvalid() { // Arrange var user = new User() { PartitionKey = "windowsliveid", RowKey = "user.test-windowsliveid" }; var taskList = new TaskList("Test title", user) { PartitionKey = "user.test-windowsliveid", RowKey = ShortGuid.NewGuid().ToString() }; var invalidTitle = string.Empty; const string validContent = "Test content"; var note = new Note(invalidTitle, validContent, user, taskList) { PartitionKey = taskList.RowKey, RowKey = ShortGuid.NewGuid().ToString() }; // Act var validationResult = note.IsValid(); // Assert Assert.IsFalse(validationResult); }
public void NotesRepositoryAddShareCallsCreateFromTheUnitOfWork() { // Arrange var user = new User { PartitionKey = User1PartitionKey, RowKey = User1RowKey }; var taskList = new TaskList("Test title", user) { PartitionKey = TaskList1PartitionKey, RowKey = _taskList1RowKey }; var note = new Note("Test title", "Test content", user, taskList); note.Share.Add(user); var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new NotesRepository(unitOfWorkMock.Object); // Act repository.AddShare(note, string.Format("{0}+{1}", User1PartitionKey, User1RowKey)); // Assert unitOfWorkMock.Verify(uow => uow.Create(It.IsAny<NoteShareEntity>(), "NoteShares"), Times.Once()); }
public void NotesServiceMethodCreateShouldCreateANote() { // Arrange var user = new User { PartitionKey = NotesMemoryRepository.IdentityProvider, RowKey = NotesMemoryRepository.User1RowKey }; var unitOfWorkMock = new Mock<IUnitOfWork>(); var taskListsRepositoryMock = new Mock<ITaskListsRepository>(); var notesRepositoryMock = new Mock<INotesRepository>(); var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object); var repository = new NotesMemoryRepository(); var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey, Owner = user }; var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService); // Act service.Create(note); var result = service.Get(note.PartitionKey, note.RowKey); // Assert Assert.IsInstanceOfType(result, typeof(Note)); Assert.IsNotNull(result); }
public void NotesRepositoryCreateCallsCreateFromTheUnitOfWork() { // Arrange var user = new User { PartitionKey = User1PartitionKey, RowKey = User1RowKey }; var taskList = new TaskList("Test title", user) { PartitionKey = TaskList1PartitionKey, RowKey = _taskList1RowKey }; var note = new Note("Test title", "Test content", user, taskList); var unitOfWorkMock = new Mock<IUnitOfWork>(); unitOfWorkMock.Setup(u => u.Load("Notes", It.IsAny<Expression<Func<NoteEntity, bool>>>())).Returns(BuildNotesTable()); var repository = new NotesRepository(unitOfWorkMock.Object); // Act repository.Create(note); // Assert Assert.IsTrue(note.PartitionKey != string.Empty); Assert.IsTrue(note.RowKey != string.Empty); unitOfWorkMock.Verify(uow => uow.Create(It.IsAny<NoteEntity>(), "Notes"), Times.Once()); unitOfWorkMock.Verify(uow => uow.Create(It.IsAny<NoteShareEntity>(), "NoteShares"), Times.Once()); unitOfWorkMock.Verify(uow => uow.Create(It.IsAny<TaskListNoteEntity>(), "TaskListNotes"), Times.Once()); }
public void NotesServiceMethodCopyNoteShouldCopyANote() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var taskListsRepositoryMock = new Mock<ITaskListsRepository>(); var notesRepositoryMock = new Mock<INotesRepository>(); var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object); var repository = new NotesMemoryRepository(); var user = new User { PartitionKey = NotesMemoryRepository.IdentityProvider, RowKey = NotesMemoryRepository.User1RowKey }; var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey, Owner = user }; var taskList = new TaskList { PartitionKey = NotesMemoryRepository.TaskList2PartitionKey, RowKey = repository.TaskList2RowKey }; var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService); // Act service.CopyNote(note, taskList); service.LoadNotes(taskList); // Assert //Assert.IsInstanceOfType(result, typeof(IQueryable<Note>)); //Assert.IsTrue(result.Count() == 2); }
/// <summary> /// Fill an User object with the unique identifier, partition key and row key. /// </summary> /// <param name="user">User to fill in the data</param> /// <param name="principal">Authenticated user IPrincipal object</param> public void FillAuthenticationInfo(User user, IPrincipal principal) { string userUniqueIdentifier = string.Empty; string identityProviderIdentifier = string.Empty; var claimsPrincipal = principal as IClaimsPrincipal; if (claimsPrincipal != null) { var claimsIdentity = claimsPrincipal.Identities[0]; var nameIdentifierClaim = claimsIdentity.Claims.FirstOrDefault(c => c.ClaimType == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier"); var identityProviderClaim = claimsIdentity.Claims.FirstOrDefault(c => c.ClaimType == "http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider"); userUniqueIdentifier = nameIdentifierClaim.Value; identityProviderIdentifier = ParseIdentityProvider(identityProviderClaim.Value); } user.UniqueIdentifier = userUniqueIdentifier; user.PartitionKey = identityProviderIdentifier; user.RowKey = string.Format("{0}-{1}", user.Name, identityProviderIdentifier); }
public TaskList(string title, User owner) : this() { Title = title; Owner = owner; }
public void TaskListsServiceMethodHasPermissionToEditShouldReturnTrueForAUserInTheShare() { // Arrange var user = new User { PartitionKey = TaskListsMemoryRepository.IdentityProvider, RowKey = TaskListsMemoryRepository.User1RowKey }; var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new TaskListsMemoryRepository(); var notesRepository = new NotesMemoryRepository(); var taskList = new TaskList { PartitionKey = TaskListsMemoryRepository.User1RowKey, RowKey = repository.TaskList1RowKey, Owner = user}; var service = new TaskListsService(unitOfWorkMock.Object, repository, notesRepository); // Act var result = service.HasPermissionToEdit(user, taskList); // Assert Assert.IsTrue(result); }
public void NotesServiceMethodHasPermissionToEditShouldReturnFalseForAUserNotInTheShare() { // Arrange var user = new User { PartitionKey = NotesMemoryRepository.IdentityProvider, RowKey = NotesMemoryRepository.User3RowKey }; var unitOfWorkMock = new Mock<IUnitOfWork>(); var taskListsRepositoryMock = new Mock<ITaskListsRepository>(); var notesRepositoryMock = new Mock<INotesRepository>(); var taskListsService = new TaskListsService(unitOfWorkMock.Object, taskListsRepositoryMock.Object, notesRepositoryMock.Object); var repository = new NotesMemoryRepository(); var note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey }; var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService); // Act var result = service.HasPermissionToEdit(user, note); // Assert Assert.IsFalse(result); }
/// <summary> /// Creates a new User. /// </summary> /// <param name="entityToCreate">User domain object with the properties to map to an Users table entity</param> public void Create(User entityToCreate) { var userTableEntry = entityToCreate.MapToUserEntity(); _unitOfWork.Create(userTableEntry, "Users"); }
/// <summary> /// Checks if a User has permissions to edit a TaskList, if it is in the TaskList Share list. /// </summary> /// <param name="user">The User to check the permission</param> /// <param name="taskList">The TaskList the User wants to edit</param> /// <returns>True if the User is in the TaskList Shares list, False otherwise</returns> public bool HasPermissionToEdit(User user, TaskList taskList) { var taskListSharePartitionKey = string.Format("{0}+{1}", taskList.PartitionKey, taskList.RowKey); return _unitOfWork.Get<TaskListShareEntity>("TaskListShares", ts => ts.PartitionKey == taskListSharePartitionKey && ts.RowKey == user.RowKey) != null; }
/// <summary> /// Gets all the TaskLists that were shared to or created by the User. /// </summary> /// <param name="user">The User to know his Shares</param> /// <returns>List of all the TaskLists shared to or created by User</returns> public IEnumerable<TaskList> GetShared(User user) { var taskLists = new List<TaskList>(); var taskListShares = _unitOfWork.Load<TaskListShareEntity>("TaskListShares", ts => ts.RowKey == user.RowKey); foreach (var taskListShare in taskListShares) { var keys = taskListShare.PartitionKey.Split('+'); var taskListPartitionKey = keys[0]; var taskListRowKey = keys[1]; var taskList = _unitOfWork.Get<TaskListEntity>("TaskLists", t => t.PartitionKey == taskListPartitionKey && t.RowKey == taskListRowKey); if (taskList != null) { taskLists.Add(taskList.MapToTaskList()); } } return taskLists.AsEnumerable(); }
public bool HasPermissionToEdit(User user, Note note) { var noteSharePartitionKey = string.Format("{0}+{1}", note.PartitionKey, note.RowKey); var noteShareRowkey = user.RowKey; return _noteShares.Any(ns => ns.PartitionKey == noteSharePartitionKey && ns.RowKey == noteShareRowkey); }
public void NotesRepositoryDeleteCallsDeletesFromTheUnitOfWork() { // Arrange var user = new User { PartitionKey = User1PartitionKey, RowKey = User1RowKey }; var taskList = new TaskList("Test title", user) { PartitionKey = TaskList1PartitionKey, RowKey = _taskList1RowKey }; var note = new Note("Test title", "Test content", user, taskList) { PartitionKey = Note1PartitionKey, RowKey = _note1RowKey }; var taskListNote = new TaskListEntity(string.Format("{0}+{1}", TaskList1PartitionKey, _taskList1RowKey), string.Format("{0}+{1}", Note1PartitionKey, _note1RowKey)); var unitOfWorkMock = new Mock<IUnitOfWork>(); unitOfWorkMock.Setup(uow => uow.Get("TaskListNotes", It.IsAny<Expression<Func<TaskListEntity, bool>>>())).Returns(taskListNote); unitOfWorkMock.Setup(uow => uow.Load<NoteShareEntity>(It.Is<string>(s => s == "NoteShares"))).Returns(BuildNoteSharesTable()); var repository = new NotesRepository(unitOfWorkMock.Object); // Act repository.Delete(note); // Assert unitOfWorkMock.Verify(uow => uow.Delete<NoteEntity>("Notes", Note1PartitionKey, _note1RowKey), Times.Once()); unitOfWorkMock.Verify(uow => uow.Delete<TaskListEntity>("TaskListNotes", taskListNote.PartitionKey, taskListNote.RowKey), Times.Once()); unitOfWorkMock.Verify(uow => uow.Delete<NoteShareEntity>("NoteShares", string.Format("{0}+{1}", Note1PartitionKey, _note1RowKey), User1RowKey), Times.Once()); unitOfWorkMock.Verify(uow => uow.Delete<NoteShareEntity>("NoteShares", string.Format("{0}+{1}", Note1PartitionKey, _note1RowKey), User3RowKey), Times.Once()); }
/// <summary> /// Updates an entity in the Users Azure Table. /// </summary> ///<param name="entityToUpdate">User domain object with the properties to update an existing Users table entity</param> public void Update(User entityToUpdate) { _unitOfWork.Update("Users", entityToUpdate.MapToUserEntity()); }
/// <summary> /// Check if the User has permission to edit the Note. /// </summary> /// <param name="user">User to check the permissio</param> /// <param name="note">Note to be edited</param> /// <returns>True if the User has permission to edit the Note, False otherwise</returns> public bool HasPermissionToEdit(User user, Note note) { return _repository.HasPermissionToEdit(user, note); }
/// <summary> /// Deletes an entity from the Users Azure Table. /// </summary> /// <param name="entityToDelete">User domain object with the properties to delete an existing Users table entity</param> public void Delete(User entityToDelete) { _unitOfWork.Delete<UserEntity>("Users", entityToDelete.PartitionKey, entityToDelete.RowKey); }
public IEnumerable<TaskList> GetShared(User user) { var taskLists = new List<TaskList>(); var taskListShares = TaskListShares.Where(t => t.RowKey == user.RowKey); foreach (var taskListShare in taskListShares) { var taskListKeys = taskListShare.PartitionKey.Split('+'); var taskListPartitionKey = taskListKeys[0]; var taskListRowKey = taskListKeys[1]; var taskList = TaskLists.FirstOrDefault(t => t.PartitionKey == taskListPartitionKey && t.RowKey == taskListRowKey); if (taskList != null) { taskLists.Add(taskList.MapToTaskList()); } } return taskLists.AsEnumerable(); }
public void TaskListsServiceMethodDeleteShouldDeleteATaskList() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new TaskListsMemoryRepository(); var notesRepository = new NotesMemoryRepository(); var service = new TaskListsService(unitOfWorkMock.Object, repository, notesRepository); var result = service.Get(TaskListsMemoryRepository.User1RowKey, repository.TaskList1RowKey); var user = new User { PartitionKey = TaskListsMemoryRepository.IdentityProvider, RowKey = TaskListsMemoryRepository.User1RowKey }; var note = new Note { PartitionKey = TaskListsMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey, Owner = user }; result.Notes.Add(note); // Act service.Delete(result); result = service.Get(TaskListsMemoryRepository.User1RowKey, repository.TaskList1RowKey); // Assert Assert.IsNull(result); }
public bool HasPermissionToEdit(User user, TaskList taskList) { var taskListSharePartitionKey = string.Format("{0}+{1}", taskList.PartitionKey, taskList.RowKey); var taskListShareRowkey = user.RowKey; return TaskListShares.Any(ns => ns.PartitionKey == taskListSharePartitionKey && ns.RowKey == taskListShareRowkey); }
public void TaskListsServiceMethodGetSharedShouldReturnAllTaskListsThatTheUserIsInTheShare() { // Arrange var user = new User { PartitionKey = TaskListsMemoryRepository.IdentityProvider, RowKey = TaskListsMemoryRepository.User3RowKey }; var unitOfWorkMock = new Mock<IUnitOfWork>(); var taskListsRepository = new TaskListsMemoryRepository(); var notesRepository = new NotesMemoryRepository(); var service = new TaskListsService(unitOfWorkMock.Object, taskListsRepository, notesRepository); // Act var result = service.GetShared(user); // Assert Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IEnumerable<TaskList>)); Assert.IsTrue(result.Count() == 2); }
/// <summary> /// Checks if a User has permissions to edit a Note, if it is in the Note Share list. /// </summary> /// <param name="user">The User to check the permission</param> /// <param name="note">The Note the User wants to edit</param> /// <returns>True if the User is in the Note Share list, False otherwise</returns> public bool HasPermissionToEdit(User user, Note note) { var noteSharePartitionKey = string.Format("{0}+{1}", note.PartitionKey, note.RowKey); return _unitOfWork.Get<NoteShareEntity>("NoteShares", ns => ns.PartitionKey == noteSharePartitionKey && ns.RowKey == user.RowKey) != null; }
public void UsersServiceMethodCreateShouldCreateAUser() { // Arrange var user = new User { PartitionKey = UsersMemoryRepository.IdentityProvider, RowKey = UsersMemoryRepository.User4RowKey }; var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new UsersMemoryRepository(); var service = new UsersService(unitOfWorkMock.Object, repository); // Act service.Create(user); var result = service.Get(UsersMemoryRepository.IdentityProvider, UsersMemoryRepository.User4RowKey); // Assert Assert.IsInstanceOfType(result, typeof(User)); Assert.IsNotNull(result); }
/// <summary> /// Update a User. /// </summary> /// <param name="entityToUpdate">User to update</param> public void Update(User entityToUpdate) { _repository.Update(entityToUpdate); _unitOfWork.SubmitChanges(); }
public void UsersServiceMethodGFillUserAuthenticationInfoShouldFillTheAuthenticationInfo() { // Arrange var claims = new[] { new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "WindowsLiveID") , new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier", "user1"), new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress", "*****@*****.**"), new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name", "user1"), }; IClaimsIdentity identity = new ClaimsIdentity(claims); IClaimsPrincipal principal = new ClaimsPrincipal(new[] { identity }); var user = new User { Name = "user1" }; var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new UsersMemoryRepository(); var service = new UsersService(unitOfWorkMock.Object, repository); // Act service.FillAuthenticationInfo(user, principal); // Assert Assert.IsTrue(user.PartitionKey == "windowsliveid"); Assert.IsTrue(user.RowKey == "user1-windowsliveid"); Assert.IsTrue(user.UniqueIdentifier == "user1"); }
/// <summary> /// Create a User. /// </summary> /// <param name="entityToCreate">User to create</param> public void Create(User entityToCreate) { _repository.Create(entityToCreate); _unitOfWork.SubmitChanges(); }
public bool Equals(User other) { return !ReferenceEquals(null, other); }
/// <summary> /// Delete a User. /// </summary> /// <param name="entityToDelete">User to delete</param> public void Delete(User entityToDelete) { _repository.Delete(entityToDelete); _unitOfWork.SubmitChanges(); }