public async Task <IActionResult> OnPostAsync(int?bucketListId)
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
if (bucketListId == null)
{
return(NotFound());
}
var bucketlistToUpdate = await _bucketListService.GetBLByIDAsync(_context, bucketListId);
if (bucketlistToUpdate == null)
{
return(NotFound());
}
if (_userService.BucketListIsNotBelongingToUser(User, bucketlistToUpdate))
{
return(Forbid());
}
// Defense against overposting attacks. Returns true if the update was successful.
if (await TryUpdateModelAsync <BucketList>(bucketlistToUpdate, "BucketList",
bl => bl.Name,
bl => bl.Visibility))
{
await _context.SaveChangesAsync();
return(RedirectToPage("./Index", new { bucketListId = bucketlistToUpdate.BucketListID }));
}
return(Page());
}
public async Task PopulateSelectedBLElementsListWithProgressionOrderedByNameAsync_PopulateBLEs_WhenNotOnlyPublicBLEsAreRequired()
{
using (var db = new BLContext(Utilities.TestDbContextOptions()))
{
// Arrange
BucketListElement publicBLE2 = new BucketListElement()
{
Name = "2",
Visibility = Visibility.Public,
BucketListID = 1,
Progression = new Progression()
{
BLETasks = new List <BLETask>()
}
};
BucketListElement publicBLE1 = new BucketListElement()
{
Name = "1",
Visibility = Visibility.Public,
BucketListID = 1,
Progression = new Progression()
{
BLETasks = new List <BLETask>()
}
};
BucketListElement privateBLE1 = new BucketListElement()
{
Name = "3",
Visibility = Visibility.Private,
BucketListID = 1,
Progression = new Progression()
{
BLETasks = new List <BLETask>()
}
};
await db.Elements.AddAsync(publicBLE2);
await db.Elements.AddAsync(publicBLE1);
await db.Elements.AddAsync(privateBLE1);
await db.SaveChangesAsync();
// Act
var actualBucketListElements = await _bucketListService.PopulateSelectedBLElementsListWithProgressionOrderedByNameAsync(db, 1, false);
// Assert
Assert.Equal(3, actualBucketListElements.Count());
Assert.Equal(publicBLE1, actualBucketListElements.ElementAt(0));
Assert.Equal(publicBLE2, actualBucketListElements.ElementAt(1));
Assert.Equal(privateBLE1, actualBucketListElements.ElementAt(2));
Assert.NotNull(actualBucketListElements.ElementAt(0).Progression.BLETasks);
Assert.NotNull(actualBucketListElements.ElementAt(1).Progression.BLETasks);
Assert.NotNull(actualBucketListElements.ElementAt(2).Progression.BLETasks);
}
}
public async Task GetCategoriesOrderedByNameWithElementsAsync_CategoriesReturnedInNameOrder_WhenDatabaseHasCategories()
{
using (var db = new BLContext(Utilities.TestDbContextOptions()))
{
// Arrange
var expectedCategories = new Category[]
{
new Category
{
Name = "1",
ElementCategories = new HashSet <ElementCategory>()
{
new ElementCategory
{
Element = new BucketListElement {
Name = "ble"
}
}
}
},
new Category
{
Name = "0",
ElementCategories = new HashSet <ElementCategory>()
{
new ElementCategory
{
Element = new Element {
Name = "e"
}
}
}
}
};
await db.Categories.AddRangeAsync(expectedCategories);
await db.SaveChangesAsync();
// Act
var actualCategories = await _bucketListService.GetCategoriesOrderedByNameWithElementsAsync(db);
// Assert
Assert.Equal(2, actualCategories.Count());
Assert.Equal(expectedCategories[1], actualCategories.ElementAt(0));
Assert.Equal(expectedCategories[0], actualCategories.ElementAt(1));
Assert.NotNull(actualCategories.ElementAt(0).ElementCategories.ElementAt(0).Element);
Assert.NotNull(actualCategories.ElementAt(1).ElementCategories.ElementAt(0).Element);
}
}
public async Task <IActionResult> OnPostAsync(int?bucketListElementId, string[] selectedCategories)
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
if (bucketListElementId == null)
{
return(NotFound());
}
var blElementToUpdate = await _bucketListService.GetBLEByIDWithBLETasksAndCategoryAsync(_context, bucketListElementId);
if (blElementToUpdate == null)
{
return(NotFound());
}
if (_userService.BucketListElementIsNotBelongingToUser(User, blElementToUpdate))
{
return(Forbid());
}
// Defense against overposting attacks. Returns true if the update was successful.
if (await TryUpdateModelAsync <BucketListElement>(blElementToUpdate, "BucketListElement",
ble => ble.Name,
ble => ble.BucketListID,
ble => ble.Description,
ble => ble.Completed,
ble => ble.Visibility,
ble => ble.Progression))
{
_bucketListService.DeleteEmptyTasks(blElementToUpdate.Progression.BLETasks);
await _bucketListService.UpdateBLElementCategoriesAsync(_context, selectedCategories, blElementToUpdate);
await _context.SaveChangesAsync();
return(RedirectToPage("DetailsBLE", new { bucketListElementId = blElementToUpdate.ElementID }));
}
//If TryUpdateModelAsync fails restore AssignedCategoryDataList and DropDownLists
AssignedCategoryDataList = await _bucketListService.PopulateAssignedCategoryDataAsync(_context, blElementToUpdate);
BucketListSL = await _bucketListService.PopulateBucketListDropDownListOrderedByNameAsync(_context, _userService.GetUserId(User), false, false, blElementToUpdate.BucketListID);
return(Page());
}
public async Task GetBLByIDAsync_BucketListIsReturned_WhenItIsFoundInDatabase()
{
using (var db = new BLContext(Utilities.TestDbContextOptions()))
{
// Arrange
BucketList expectedBucketList = new BucketList()
{
BucketListID = 1
};
await db.BucketLists.AddAsync(expectedBucketList);
await db.SaveChangesAsync();
// Act
var actualBucketList = await _bucketListService.GetBLByIDAsync(db, 1);
// Assert
Assert.Equal(expectedBucketList, actualBucketList);
}
}
public async Task <IActionResult> OnPostAsync(int?bucketListId, string[] selectedCategories)
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
if (bucketListId == null)
{
return(NotFound());
}
var newBLElement = await _bucketListService.InitializeBLEWithBLAsync(_context, bucketListId);
_bucketListService.AddCategoriesToBLE(selectedCategories, newBLElement);
if (_userService.BucketListIsNotBelongingToUser(User, newBLElement.BucketList))
{
return(Forbid());
}
// Defense against overposting attacks. Returns true if the update was successful.
if (await TryUpdateModelAsync <BucketListElement>(newBLElement, "BucketListElement",
ble => ble.Name,
ble => ble.Description,
ble => ble.Completed,
ble => ble.Visibility))
{
await _context.BLElements.AddAsync(newBLElement);
await _context.SaveChangesAsync();
return(RedirectToPage("../BucketLists/Index", new { bucketListId = bucketListId }));
}
//If TryUpdateModelAsync fails restore AssignedCategoryDataList and DropDownLists
AssignedCategoryDataList = await _bucketListService.PopulateAssignedCategoryDataAsync(_context, newBLElement);
BucketListSL = await _bucketListService.PopulateBucketListDropDownListOrderedByNameAsync(_context, _userService.GetUserId(User), false, false, newBLElement.BucketListID);
return(Page());
}
public async Task <IActionResult> OnPostAsync()
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
BucketList.UserId = _userService.GetUserId(User);
var emptyBucketList = new BucketList();
if (await TryUpdateModelAsync <BucketList>(emptyBucketList, "BucketList",
bl => bl.Name,
bl => bl.UserId))
{
await _context.BucketLists.AddAsync(BucketList);
await _context.SaveChangesAsync();
return(RedirectToPage("./Index", new { bucketListId = BucketList.BucketListID }));
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(int?bucketListElementId)
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
if (bucketListElementId == null)
{
return(NotFound());
}
var BLElementToRemove = await _bucketListService.GetBLEByIDWithBLAsync(_context, bucketListElementId);
if (BLElementToRemove == null)
{
return(NotFound());
}
if (_userService.BucketListElementIsNotBelongingToUser(User, BLElementToRemove))
{
return(Forbid());
}
try
{
_context.BLElements.Remove(BLElementToRemove);
await _context.SaveChangesAsync();
return(RedirectToPage("../BucketLists/Index", new { bucketListId = BLElementToRemove.BucketListID }));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
return(RedirectToAction("DeleteBLE", new { bucketListElementId, saveChangesError = true }));
}
}
