/// <summary> /// Copy a Note to another TaskList. /// </summary> /// <param name="note">Note to be copied</param> /// <param name="taskListDestination">TaskList where the Note will be copied</param> /// <returns>The Note's Copy new row key</returns> public string CopyNote(Note note, TaskList taskListDestination) { var noteCopy = new Note { PartitionKey = note.PartitionKey, RowKey = ShortGuid.NewGuid(), IsClosed = note.IsClosed, OrderingIndex = note.OrderingIndex, Owner = note.Owner, Title = note.Title, Content = note.Content, Container = taskListDestination }; _repository.Create(noteCopy); // copy the original Note share list to the copied Note share list. foreach (var share in note.Share) { if (share.RowKey != note.Owner.RowKey) { _repository.AddShare(noteCopy, share.RowKey); } } _unitOfWork.SubmitChanges(); return noteCopy.RowKey; }
/// <summary> /// Creates a new Note. /// </summary> /// <param name="entityToCreate">Note domain object with the properties to map to an Notes table entity</param> public void Create(Note entityToCreate) { // get the last inserted Note ordering index var maxOrderingIndex = -1; var result = _unitOfWork.Load<NoteEntity>("Notes", n => n.PartitionKey == entityToCreate.Owner.RowKey).ToList(); if (result.Any()) { maxOrderingIndex = result.Max(n => n.OrderingIndex); } entityToCreate.PartitionKey = entityToCreate.Owner.RowKey; entityToCreate.RowKey = ShortGuid.NewGuid(); entityToCreate.OrderingIndex = maxOrderingIndex + 1; entityToCreate.ContainerKeys = string.Format("{0}+{1}", entityToCreate.Container.PartitionKey, entityToCreate.Container.RowKey); var noteEntity = entityToCreate.MapToNoteEntity(); _unitOfWork.Create(noteEntity, "Notes"); // the User that creates the new Note is automatically add in the Note Shares list. var noteSharePartitionKey = string.Format("{0}+{1}", entityToCreate.PartitionKey, entityToCreate.RowKey); var noteShare = new NoteShareEntity(noteSharePartitionKey, entityToCreate.Owner.RowKey); _unitOfWork.Create(noteShare, "NoteShares"); // store in the TaskListNotes an entity to indicate that the Note is in the containing TaskList. var taskListNoteEntityPartitionKey = string.Format("{0}+{1}", entityToCreate.Container.PartitionKey, entityToCreate.Container.RowKey); var taskListNoteEntityRowKey = string.Format("{0}+{1}", entityToCreate.PartitionKey, entityToCreate.RowKey); var taskListNoteEntity = new TaskListNoteEntity(taskListNoteEntityPartitionKey, taskListNoteEntityRowKey); _unitOfWork.Create(taskListNoteEntity, "TaskListNotes"); }
public void Create(Note entityToCreate) { var note = entityToCreate.MapToNoteEntity(); var maxIndex = _notes.Max(n => n.OrderingIndex); note.OrderingIndex = maxIndex + 1; var noteShare = new NoteShareEntity(entityToCreate.RowKey, entityToCreate.Owner.RowKey); _notes.Add(note); _noteShares.Add(noteShare); }
public void ANoteWithAnEmptyContentIsInvalid() { // 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() }; const string validTitle = "Test title"; string invalidContent = string.Empty; var note = new Note(validTitle, invalidContent, user, taskList) { PartitionKey = taskList.RowKey, RowKey = ShortGuid.NewGuid().ToString() }; // Act var validationResult = note.IsValid(); // Assert Assert.IsFalse(validationResult); }
public void ANoteWithAllValidPropertiesIsValid() { // 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() }; const string validTitle = "Test title"; const string validContent = "Test content"; var note = new Note(validTitle, validContent, user, taskList) { PartitionKey = taskList.RowKey, RowKey = ShortGuid.NewGuid().ToString() }; // Act var validationResult = note.IsValid(); // Assert Assert.IsTrue(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 NotesServiceMethodAddShareShouldAddAUserToTheNoteShares() { // 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 note = new Note { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.Note1RowKey }; var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService); var noteSharesCount = repository._noteShares.Count; // Act service.AddShare(note, NotesMemoryRepository.User2RowKey); // Assert Assert.IsTrue(repository._noteShares.Count == noteSharesCount + 1); }
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 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 static Note MapToNote(this NoteEntity entry) { Note note = null; if (entry != null) { note = new Note { PartitionKey = entry.PartitionKey, RowKey = entry.RowKey, Timestamp = entry.Timestamp, Title = entry.Title, Content = entry.Content, IsClosed = entry.IsClosed, OrderingIndex = entry.OrderingIndex, ContainerKeys = entry.ContainerKeys }; } return note; }
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); }
public void NotesServiceMethodHasPermissionToEditShouldReturnTrueForAUserInTheShare() { // 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 var result = service.HasPermissionToEdit(user, note); // Assert Assert.IsTrue(result); }
/// <summary> /// Fills the note share users list. /// </summary> /// <param name="note">Note to have the Share list filled</param> public void LoadShare(Note note) { var noteSharePartitionKey = string.Format("{0}+{1}", note.PartitionKey, note.RowKey); var noteShares = _unitOfWork.Load<NoteShareEntity>("NoteShares", n => n.PartitionKey == noteSharePartitionKey); foreach (var noteShare in noteShares) { var userKeys = noteShare.RowKey.Split('-'); var identityProvider = userKeys[1]; var share = Get(identityProvider, noteShare.RowKey); if (share != null) { note.Share.Add(share); } } }
/// <summary> /// Fills the Note Owner information with an User object. /// </summary> /// <param name="note">Note to have the Owner filled.</param> public void LoadOwner(Note note) { var ownerKeys = note.PartitionKey.Split('-'); var ownerPartitionKey = ownerKeys[1]; var owner = Get(ownerPartitionKey, note.PartitionKey); if (owner != null) { note.Owner = owner; } }
/// <summary> /// Load all the Users that the Note was shared with. /// </summary> /// <param name="note">Note to fill the Share list</param> public void LoadShare(Note note) { _repository.LoadShare(note); }
/// <summary> /// Load the User that created the Note. /// </summary> /// <param name="note">Note to fill the Owner data</param> public void LoadOwner(Note note) { _repository.LoadOwner(note); }
/// <summary> /// Create a Note. /// </summary> /// <param name="entityToCreate">Note to create</param> public void Create(Note entityToCreate) { _repository.Create(entityToCreate); _unitOfWork.SubmitChanges(); }
/// <summary> /// Share the Note with a User. /// </summary> /// <param name="note">The Note to be shared</param> /// <param name="userId">RowKey from the User</param> public void AddShare(Note note, string userId) { var sharePartitionKey = string.Format("{0}+{1}", note.PartitionKey, note.RowKey); var share = new NoteShareEntity(sharePartitionKey, userId); _unitOfWork.Create(share, "NoteShares"); }
/// <summary> /// Update a Note. /// </summary> /// <param name="entityToUpdate">Note to update</param> public void Update(Note entityToUpdate) { _repository.Update(entityToUpdate); _unitOfWork.SubmitChanges(); }
public void UsersServiceMethodLoadNoteOwnerShouldLoadOwner() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new UsersMemoryRepository(); var note = new Note { PartitionKey = UsersMemoryRepository.Note1PartitionKey, RowKey = repository.Note1RowKey }; var service = new UsersService(unitOfWorkMock.Object, repository); // Act service.LoadOwner(note); // Assert Assert.IsNotNull(note.Owner); }
/// <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 LoadContainer(Note note) { var taskListNote = TaskListNotes.FirstOrDefault(tn => tn.RowKey == string.Format("{0}+{1}", note.PartitionKey, note.RowKey)); if (taskListNote != null) { var taskListKeys = taskListNote.PartitionKey.Split('+'); var taskListPartitionKey = taskListKeys[0]; var taskListRowKey = taskListKeys[1]; var taskList = TaskLists.FirstOrDefault(t => t.PartitionKey == taskListPartitionKey && t.RowKey == taskListRowKey); if (taskList != null) { note.Container = taskList.MapToTaskList(); } } }
/// <summary> /// Delete a Note. /// </summary> /// <param name="entityToDelete">Note to delete</param> public void Delete(Note entityToDelete) { _repository.Delete(entityToDelete); _unitOfWork.SubmitChanges(); }
/// <summary> /// Move a Note to another TaskList. /// </summary> /// <param name="note">Note to be moved</param> /// <param name="taskListDestination">TaskList where the Note will be moved</param> /// <returns></returns> public string MoveNote(Note note, TaskList taskListDestination) { _repository.Delete(note); return CopyNote(note, taskListDestination); }
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); }
/// <summary> /// Deletes an entity from the Notes Azure Table and all the entities in the related Azure Tables. /// </summary> /// <param name="entityToDelete">TaskList domain object with the properties to delete an existing TaskLists table entity</param> public void Delete(Note entityToDelete) { _unitOfWork.Delete<NoteEntity>("Notes", entityToDelete.PartitionKey, entityToDelete.RowKey); // delete all the entities that relate a Containing TaskList and his Notes. var taskListNoteRowKey = string.Format("{0}+{1}", entityToDelete.PartitionKey, entityToDelete.RowKey); var taskListNote = _unitOfWork.Get<TaskListEntity>("TaskListNotes", tn => tn.RowKey == taskListNoteRowKey); _unitOfWork.Delete<TaskListEntity>("TaskListNotes", taskListNote.PartitionKey, taskListNote.RowKey); // delete all the entities related to the Note Shares list. var noteSharePartitionKey = string.Format("{0}+{1}", entityToDelete.PartitionKey, entityToDelete.RowKey); var shares = _unitOfWork.Load<NoteShareEntity>("NoteShares").Where(n => n.PartitionKey == noteSharePartitionKey); foreach (var share in shares) { _unitOfWork.Delete<NoteShareEntity>("NoteShares", share.PartitionKey, share.RowKey); } }
/// <summary> /// Remove an existing Share from the Note. /// </summary> /// <param name="note">The Note with the Share to be removed</param> /// <param name="userId">RowKey from the User</param> public void RemoveShare(Note note, string userId) { var sharePartitionKey = string.Format("{0}+{1}", note.PartitionKey, note.RowKey); _unitOfWork.Delete<NoteShareEntity>("NoteShares", sharePartitionKey, userId); }
/// <summary> /// Share the Note with a User. /// </summary> /// <param name="note">Note to be shared</param> /// <param name="userId">The User row key</param> public void AddShare(Note note, string userId) { _repository.AddShare(note, userId); _unitOfWork.SubmitChanges(); }
public void UsersServiceMethodLoadShareShouldLoadTheNoteShares() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new UsersMemoryRepository(); var note = new Note { PartitionKey = UsersMemoryRepository.Note1PartitionKey, RowKey = repository.Note1RowKey }; var service = new UsersService(unitOfWorkMock.Object, repository); // Act service.LoadShare(note); // Assert Assert.IsTrue(note.Share.Count == 2); }
/// <summary> /// Updates an entity in the Notes Azure Table. /// </summary> /// <param name="entityToUpdate">Note domain object with the properties to update an existing Notes table entity</param> public void Update(Note entityToUpdate) { _unitOfWork.Update("Notes", entityToUpdate.MapToNoteEntity()); }