public async Task <Bookmark?> GetBookmark(string userId, int bookmarkId)
{
if (!BookmarkOwnershipTools.IsBookmarkOwner(this.db, userId, bookmarkId))
{
return(null);
}
return(await this.db.Bookmarks
.SingleOrDefaultAsync(b => b.BookmarkId == bookmarkId));
}
public async Task <BookmarkGroup?> GetBookmarkGroup(string userId, int bookmarkGroupId,
bool includeBookmarks = false)
{
BookmarkGroup?group = await db.BookmarkGroups
.Where(bg => bg.BookmarkGroupId == bookmarkGroupId)
.If(includeBookmarks, q => q.Include(bg => bg.Bookmarks))
.SingleOrDefaultAsync();
if (!BookmarkOwnershipTools.IsBookmarkGroupOwner(db, userId, bookmarkGroupId))
{
return(null);
}
return(group);
}
public async Task <BookmarkGroup?> CreateBookmarkGroup(string userId, string title,
string color, int sortOrder, int bookmarkContainerId)
{
if (!BookmarkOwnershipTools
.IsBookmarkContainerOwner(this.db, userId, bookmarkContainerId))
{
return(null);
}
BookmarkGroup newBookmarkGroup = new(title, color, sortOrder, bookmarkContainerId);
await this.db.BookmarkGroups.AddAsync(newBookmarkGroup);
await this.db.SaveChangesAsync();
return(newBookmarkGroup);
}
public async Task <BookmarkContainer?> UpdateBookmarkContainer(string userId,
BookmarkContainer bookmarkContainer)
{
BookmarkContainer?existingBookmarkContainer = await this.db.BookmarkContainers
.SingleOrDefaultAsync(bc =>
bc.BookmarkContainerId == bookmarkContainer.BookmarkContainerId);
if (existingBookmarkContainer == null ||
!BookmarkOwnershipTools
.IsBookmarkContainerOwner(this.db, userId, bookmarkContainer.BookmarkContainerId))
{
return(null);
}
// If the sort order has changed, then the other containers need to be shuffled around
if (existingBookmarkContainer.SortOrder < bookmarkContainer.SortOrder)
{
// The container has been moved to a higher sort order
var affectedContainers = db.BookmarkContainers
.Where(bc => bc.ApplicationUserId == userId)
.Where(bc => bc.SortOrder > existingBookmarkContainer.SortOrder)
.Where(bc => bc.SortOrder <= bookmarkContainer.SortOrder)
.ToList();
affectedContainers.ForEach(bc => bc.SortOrder -= 1);
// Let the save changes below save this
}
else if (existingBookmarkContainer.SortOrder > bookmarkContainer.SortOrder)
{
// The container has been moved to a lower sort order
var affectedContainers = db.BookmarkContainers
.Where(bc => bc.ApplicationUserId == userId)
.Where(bc => bc.SortOrder < existingBookmarkContainer.SortOrder)
.Where(bc => bc.SortOrder >= bookmarkContainer.SortOrder)
.ToList();
affectedContainers.ForEach(bc => bc.SortOrder += 1);
// Let the save changes below save this
}
this.db.Entry(bookmarkContainer).State = EntityState.Modified;
await this.db.SaveChangesAsync();
return(bookmarkContainer);
}
public async Task <bool> DeleteBookmark(string userId, int bookmarkId)
{
Bookmark?bookmark = db.Bookmarks
.SingleOrDefault(b => b.BookmarkId == bookmarkId);
if (bookmark == null)
{
return(false);
}
if (!BookmarkOwnershipTools.IsBookmarkOwner(this.db, userId, bookmarkId))
{
return(false);
}
db.Bookmarks.Remove(bookmark);
await db.SaveChangesAsync();
return(true);
}
public async Task <bool> DeleteBookmarkGroup(string userId, int bookmarkGroupId)
{
BookmarkGroup?bookmarkGroup = await this.db.BookmarkGroups
.SingleOrDefaultAsync(bg => bg.BookmarkGroupId == bookmarkGroupId);
if (bookmarkGroup == null)
{
return(false);
}
if (!BookmarkOwnershipTools.IsBookmarkGroupOwner(this.db, userId, bookmarkGroupId))
{
return(false);
}
this.db.BookmarkGroups.Remove(bookmarkGroup);
await this.db.SaveChangesAsync();
return(true);
}
public async Task <Bookmark?> CreateBookmark(string userId, string title, string url,
string?notes, int sortOrder, int bookmarkGroupId)
{
if (!BookmarkOwnershipTools.IsBookmarkGroupOwner(this.db, userId, bookmarkGroupId))
{
return(null);
}
Bookmark newBookmark = new(title, url, notes, sortOrder, bookmarkGroupId);
await db.Bookmarks.AddAsync(newBookmark);
await db.SaveChangesAsync();
if (newBookmark.BookmarkId <= 0)
{
return(null);
}
return(newBookmark);
}
public async Task <bool> DeleteBookmarkContainer(string userId, int bookmarkContainerId)
{
BookmarkContainer?bookmarkContainer = await this.db.BookmarkContainers
.Where(bc => bc.BookmarkContainerId == bookmarkContainerId)
.SingleOrDefaultAsync();
if (bookmarkContainer == null)
{
return(false);
}
if (!BookmarkOwnershipTools.IsBookmarkContainerOwner(this.db, userId, bookmarkContainerId))
{
return(false);
}
this.db.BookmarkContainers.Remove(bookmarkContainer);
await this.db.SaveChangesAsync();
List <BookmarkContainer>?containers = this.db.BookmarkContainers
.Where(bc => bc.ApplicationUserId == userId)
.SortContainers()
.ToList();
if (containers == null)
{
// The container *was* deleted, so indicate as such
return(true);
}
// Fix up sort order just in case
for (int i = 0; i < containers.Count; i++)
{
containers[i].SortOrder = i;
}
await this.db.SaveChangesAsync();
return(true);
}
public async Task <BookmarkContainer?> GetBookmarkContainer(string userId,
int bookmarkContainerId, bool includeGroups = false, bool includeBookmarks = false)
{
BookmarkContainer?bookmarkContainer = await this.db.BookmarkContainers
.Where(bc => bc.BookmarkContainerId == bookmarkContainerId)
.If(includeGroups, q => q.Include(bc => bc.BookmarkGroups))
.If(includeBookmarks, q => q
.Include(bc => bc.BookmarkGroups !)
.ThenInclude(bg => bg.Bookmarks))
.SingleOrDefaultAsync();
if (bookmarkContainer == null)
{
return(null);
}
if (!BookmarkOwnershipTools
.IsBookmarkContainerOwner(this.db, userId, bookmarkContainerId))
{
return(null);
}
return(bookmarkContainer);
}
public async Task <Bookmark?> UpdateBookmark(string userId, Bookmark bookmark)
{
Bookmark?existingBookmark = await db.Bookmarks
.SingleOrDefaultAsync(b => b.BookmarkId == bookmark.BookmarkId);
if (existingBookmark == null)
{
return(null);
}
if (!BookmarkOwnershipTools.IsBookmarkOwner(this.db, userId, bookmark.BookmarkId))
{
return(null);
}
// Could be moving to a different group
if (!BookmarkOwnershipTools
.IsBookmarkGroupOwner(this.db, userId, bookmark.BookmarkGroupId))
{
return(null);
}
if (bookmark.BookmarkGroupId != existingBookmark.BookmarkGroupId)
{
// The bookmark was moved to a different group - shuffle sort order around
List <Bookmark>?oldGroupBookmarks = await db.Bookmarks
.Where(b => b.BookmarkGroupId == existingBookmark.BookmarkGroupId)
.Where(b => b.SortOrder > existingBookmark.SortOrder)
.ToListAsync();
oldGroupBookmarks.ForEach(b => b.SortOrder -= 1);
List <Bookmark>?newGroupBookmarks = await db.Bookmarks
.Where(b => b.BookmarkGroupId == bookmark.BookmarkGroupId)
.Where(b => b.SortOrder >= bookmark.SortOrder)
.ToListAsync();
newGroupBookmarks.ForEach(b => b.SortOrder += 1);
}
else if (bookmark.SortOrder != existingBookmark.SortOrder)
{
// The bookmark has been moved within the same group
List <Bookmark>?groupBookmarks = await db.Bookmarks
.Where(b => b.BookmarkGroupId == bookmark.BookmarkGroupId)
.Where(b => b.BookmarkId != bookmark.BookmarkId)
.ToListAsync();
groupBookmarks
.Where(b => b.SortOrder > existingBookmark.SortOrder)
.ToList()
.ForEach(b => b.SortOrder -= 1);
groupBookmarks
.Where(b => b.SortOrder > bookmark.SortOrder)
.ToList()
.ForEach(b => b.SortOrder += 1);
}
db.Entry(bookmark).State = EntityState.Modified;
await db.SaveChangesAsync();
return(bookmark);
}
public async Task <BookmarkGroup?> UpdateBookmarkGroup(string userId,
BookmarkGroup bookmarkGroup)
{
BookmarkGroup?existingGroup = await this.db.BookmarkGroups
.SingleOrDefaultAsync(bg => bg.BookmarkGroupId == bookmarkGroup.BookmarkGroupId);
if (existingGroup == null)
{
return(null);
}
if (!BookmarkOwnershipTools
.IsBookmarkGroupOwner(this.db, userId, bookmarkGroup.BookmarkGroupId))
{
return(null);
}
// If it's been moved to a new container
if (existingGroup.BookmarkContainerId != bookmarkGroup.BookmarkContainerId &&
!BookmarkOwnershipTools
.IsBookmarkContainerOwner(this.db, userId, bookmarkGroup.BookmarkContainerId))
{
return(null);
}
if (existingGroup.BookmarkContainerId != bookmarkGroup.BookmarkContainerId)
{
// It's been moved to a different container - shuffle the sort order around
List <BookmarkGroup>?oldContainerGroups = await db.BookmarkGroups
.Where(bg => bg.BookmarkContainerId == existingGroup.BookmarkContainerId)
.Where(bg => bg.SortOrder > existingGroup.SortOrder)
.ToListAsync();
oldContainerGroups.ForEach(bg => bg.SortOrder -= 1);
List <BookmarkGroup>?newContainerGroups = await db.BookmarkGroups
.Where(bg => bg.BookmarkContainerId == bookmarkGroup.BookmarkContainerId)
.Where(bg => bg.SortOrder >= bookmarkGroup.SortOrder)
.ToListAsync();
newContainerGroups.ForEach(bg => bg.SortOrder += 1);
}
else if (existingGroup.SortOrder != bookmarkGroup.SortOrder)
{
// The group was moved within the same container
List <BookmarkGroup>?containerGroups = await db.BookmarkGroups
.Where(bg => bg.BookmarkContainerId == bookmarkGroup.BookmarkContainerId)
.Where(bg => bg.BookmarkGroupId != bookmarkGroup.BookmarkGroupId)
.ToListAsync();
containerGroups
.Where(bg => bg.SortOrder > existingGroup.SortOrder)
.ToList()
.ForEach(bg => bg.SortOrder -= 1);
containerGroups
.Where(bg => bg.SortOrder > bookmarkGroup.SortOrder)
.ToList()
.ForEach(bg => bg.SortOrder += 1);
}
this.db.Entry(bookmarkGroup).State = EntityState.Modified;
await this.db.SaveChangesAsync();
return(bookmarkGroup);
}
