/// <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; }
public ActionResult CreatePost() { var currentUser = (User) Session["CurrentUser"]; var taskList = new TaskList { Owner = currentUser }; try { TryUpdateModel(taskList); // Check if a tasklist already exists with the same title. var existingTaskList = _taskListsService.Get(t => t.PartitionKey == currentUser.RowKey && t.Title == taskList.Title); if (existingTaskList != null) { ViewBag.ValidationErrors = new List<ValidationResult> { new ValidationResult(string.Format("The taskList with the title '{0}' already exists.", taskList.Title)) }; return View(taskList); } if (taskList.IsValid()) { _taskListsService.Create(taskList); return RedirectToAction("Index"); } else { ViewBag.ValidationErrors = taskList.GetValidationErrors(); } } catch (Exception ex) { ViewBag.ValidationErrors = new List<ValidationResult> { new ValidationResult(string.Format("Create taskList exception: {0}", ex.Message)) }; } return View(taskList); }
public void Create(TaskList entityToCreate) { var taskList = entityToCreate.MapToTaskListEntity(); var taskListShare = new TaskListShareEntity(entityToCreate.RowKey, entityToCreate.Owner.RowKey); TaskLists.Add(taskList); TaskListShares.Add(taskListShare); }
public Note(string title, string content, User owner, TaskList containerList) : this() { Title = title; Content = content; Owner = owner; Container = containerList; }
/// <summary> /// Creates a new TaskList. /// </summary> /// <param name="entityToCreate">TaskList domain object with the properties to map to an TaskLists table entity</param> public void Create(TaskList entityToCreate) { entityToCreate.PartitionKey = entityToCreate.Owner.RowKey; entityToCreate.RowKey = ShortGuid.NewGuid(); var taskListEntity = entityToCreate.MapToTaskListEntity(); _unitOfWork.Create(taskListEntity, "TaskLists"); // the User that creates the new TaskList is automatically add in the TaskList Shares list. var sharePartitionKey = string.Format("{0}+{1}", entityToCreate.PartitionKey, entityToCreate.RowKey); var taskListShare = new TaskListShareEntity(sharePartitionKey, entityToCreate.Owner.RowKey); _unitOfWork.Create(taskListShare, "TaskListShares"); }
/// <summary> /// Delete a TaskList and his Notes. /// </summary> /// <param name="entityToDelete">TaskList to delete</param> public void Delete(TaskList entityToDelete) { _notesRepository.LoadNotes(entityToDelete); foreach (var note in entityToDelete.Notes) { _notesRepository.Delete(note); } _taskListsRepository.Delete(entityToDelete); _unitOfWork.SubmitChanges(); }
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 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 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 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> /// Deletes an entity from the TaskLists 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(TaskList entityToDelete) { _unitOfWork.Delete<TaskListEntity>("TaskLists", entityToDelete.PartitionKey, entityToDelete.RowKey); // delete all the entities related to the TaskList Shares list. var sharePartitionKey = string.Format("{0}+{1}", entityToDelete.PartitionKey, entityToDelete.RowKey); var taskListShares = _unitOfWork.Load<TaskListShareEntity>("TaskListShares", ts => ts.PartitionKey == sharePartitionKey); foreach (var taskListShare in taskListShares) { _unitOfWork.Delete<TaskListShareEntity>("TaskListShares", taskListShare.PartitionKey, taskListShare.RowKey); } // delete all the TaskList Notes. var taskListNotePartitionKey = sharePartitionKey; var taskListNotes = _unitOfWork.Load<TaskListNoteEntity>("TaskListNotes", ts => ts.PartitionKey == taskListNotePartitionKey); foreach (var taskListNoteEntity in taskListNotes) { _unitOfWork.Delete<TaskListNoteEntity>("TaskListNotes", taskListNoteEntity.PartitionKey, taskListNoteEntity.RowKey); } }
/// <summary> /// Checks if a TaskList already has a Note with the provided title. /// </summary> /// <param name="title">The title to check if exists</param> /// <param name="container">The TaskList to check if a Note exists wiht the provided title</param> /// <returns>True if a Note already exists with the title, False otherwise</returns> public bool NoteWithTitleExists(string title, TaskList container) { var containerKeys = string.Format("{0}+{1}", container.PartitionKey, container.RowKey); var note = _unitOfWork.Get<Note>("Notes", n => n.ContainerKeys == containerKeys && n.Title == title); return note != null; }
public void NotesServiceMethodNoteWithTitleExistsShouldReturnTrueForAnExistingTitle() { // 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 taskList = new TaskList { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.TaskList1RowKey }; var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService); // Act var result = service.NoteWithTitleExists("Test title", taskList); // Assert Assert.IsTrue(result); }
public void TaskListsServiceMethodCreateShouldCreateATaskList() { // 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.TaskList3RowKey, Owner = user }; var service = new TaskListsService(unitOfWorkMock.Object, repository, notesRepository); // Act service.Create(taskList); var result = service.Get(NotesMemoryRepository.User1RowKey, repository.TaskList3RowKey); // Assert Assert.IsInstanceOfType(result, typeof(TaskList)); Assert.IsNotNull(result); }
/// <summary> /// Fills the tasklist share users list. /// </summary> /// <param name="taskList">TaskList to have the Share list filled</param> public void LoadShare(TaskList taskList) { var taskListSharePartitionKey = string.Format("{0}+{1}", taskList.PartitionKey, taskList.RowKey); var taskListShares = _unitOfWork.Load<TaskListShareEntity>("TaskListShares", n => n.PartitionKey == taskListSharePartitionKey); foreach (var taskListShare in taskListShares) { var userKeys = taskListShare.RowKey.Split('-'); var identityProvider = userKeys[1]; var share = Get(identityProvider, taskListShare.RowKey); if (share != null) { taskList.Share.Add(share); } } }
public void NotesServiceMethodLoadNotesShouldLoadAllNotes() { // 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 taskList = new TaskList { PartitionKey = NotesMemoryRepository.User1RowKey, RowKey = repository.TaskList1RowKey }; var service = new NotesService(unitOfWorkMock.Object, repository, taskListsService); // Act service.LoadNotes(taskList); // Assert Assert.IsTrue(taskList.Notes.Count == 2); }
/// <summary> /// Load all the Users that the TaskList was shared with. /// </summary> /// <param name="taskList">TaskList to fill the Share list</param> public void LoadShare(TaskList taskList) { _repository.LoadShare(taskList); }
/// <summary> /// Fills the TaskList Owner information wiht an User object. /// </summary> /// <param name="taskList">TaskList to have the Owner filled.</param> public void LoadOwner(TaskList taskList) { var userKeys = taskList.PartitionKey.Split('-'); var identityProvider = userKeys[1]; var owner = Get(identityProvider, taskList.PartitionKey); taskList.Owner = owner; }
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); }
/// <summary> /// Load the User that created the TaskList. /// </summary> /// <param name="taskList">TaskList to fill the Owner data</param> public void LoadOwner(TaskList taskList) { _repository.LoadOwner(taskList); }
public void RemoveShare(TaskList taskList, string userId) { TaskListShares.RemoveAll(n => n.PartitionKey == string.Format("{0}+{1}", taskList.PartitionKey, taskList.RowKey) && n.RowKey == userId); }
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 UsersServiceMethodLoadShareShouldLoadTheTaskListShares() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new UsersMemoryRepository(); var taskList = new TaskList { PartitionKey = UsersMemoryRepository.TaskList1PartitionKey, RowKey = repository.TaskList1RowKey }; var service = new UsersService(unitOfWorkMock.Object, repository); // Act service.LoadShare(taskList); // Assert Assert.IsTrue(taskList.Share.Count == 2); }
public void AddShare(TaskList taskList, string userId) { TaskListShares.Add(new TaskListShareEntity(string.Format("{0}+{1}", taskList.PartitionKey, taskList.RowKey), userId)); }
public void Update(TaskList entityToUpdate) { var taskList = entityToUpdate.MapToTaskListEntity(); var taskListToRemove = TaskLists.First(n => n.PartitionKey == taskList.PartitionKey && n.RowKey == taskList.RowKey); TaskLists.Remove(taskListToRemove); TaskLists.Add(taskList); }
public void TaskListsServiceMethodRemoveShareShouldARemoveAUserFromTheTaskListShares() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new TaskListsMemoryRepository(); var notesRepository = new NotesMemoryRepository(); var taskList = new TaskList { PartitionKey = TaskListsMemoryRepository.User1RowKey, RowKey = repository.TaskList1RowKey }; var service = new TaskListsService(unitOfWorkMock.Object, repository, notesRepository); var taskListSharesCount = repository.TaskListShares.Count; // Act service.RemoveShare(taskList, TaskListsMemoryRepository.User3RowKey); // Assert Assert.IsTrue(repository.TaskListShares.Count == taskListSharesCount - 1); }
/// <summary> /// Loads and fills all the Notes for a TaskList. /// </summary> /// <param name="taskList">The TaskList to fill the Notes</param> public void LoadNotes(TaskList taskList) { var buffer = new List<Note>(); var taskListNotePartitionKey = string.Format("{0}+{1}", taskList.PartitionKey, taskList.RowKey); var taskListNotes = _unitOfWork.Load<TaskListNoteEntity>("TaskListNotes", n => n.PartitionKey == taskListNotePartitionKey); foreach (var taskListNote in taskListNotes) { var noteKeys = taskListNote.RowKey.Split('+'); var notePartitionKey = noteKeys[0]; var noteRowKey = noteKeys[1]; var note = Get(notePartitionKey, noteRowKey); if (note != null) { buffer.Add(note); } } // insert the Notes maintaining the ascending order for the ordering index. foreach (var note in buffer.OrderBy(n => n.OrderingIndex)) { taskList.Notes.Add(note); } }
public void UsersServiceMethodLoadTaskListOwnerShouldLoadOwner() { // Arrange var unitOfWorkMock = new Mock<IUnitOfWork>(); var repository = new UsersMemoryRepository(); var taskList = new TaskList { PartitionKey = UsersMemoryRepository.TaskList1PartitionKey, RowKey = repository.Note1RowKey }; var service = new UsersService(unitOfWorkMock.Object, repository); // Act service.LoadOwner(taskList); // Assert Assert.IsNotNull(taskList.Owner); }
public void Delete(TaskList entityToDelete) { TaskLists.RemoveAll(n => n.PartitionKey == entityToDelete.PartitionKey && n.RowKey == entityToDelete.RowKey); TaskListShares.RemoveAll(n => n.PartitionKey == entityToDelete.RowKey); }