Beispiel #1
0
        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));
        }
Beispiel #2
0
        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);
        }
Beispiel #3
0
        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);
        }