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