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