Created Woodpecker CI/CD deployment

- Created Dockerfile for packing up API and Web projects as Docker image
2023-03-27 21:48:25 -05:00
parent baf38aa3cd
commit a5d5ed048f
145 changed files with 30973 additions and 18248 deletions
--- a/API/YABA.Service/BookmarkService.cs
+++ b/API/YABA.Service/BookmarkService.cs
@ -0,0 +1,280 @@
+using AutoMapper;
+using HtmlAgilityPack;
+using Microsoft.AspNetCore.Http;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using YABA.Common.DTOs.Bookmarks;
+using YABA.Common.DTOs.Tags;
+using YABA.Common.Extensions;
+using YABA.Common.Interfaces;
+using YABA.Data.Context;
+using YABA.Data.Extensions;
+using YABA.Models;
+using YABA.Service.Interfaces;
+
+namespace YABA.Service
+{
+    public class BookmarkService : IBookmarkService
+    {
+        private readonly YABAReadOnlyContext _roContext;
+        private readonly YABAReadWriteContext _context;
+        private readonly IHttpContextAccessor _httpContextAccessor;
+        private readonly IMapper _mapper;
+
+        public BookmarkService(
+            YABAReadOnlyContext roContext, 
+            YABAReadWriteContext context, 
+            IHttpContextAccessor httpContextAccessor,
+            IMapper mapper)
+        {
+            _roContext = roContext;
+            _context = context;
+            _httpContextAccessor = httpContextAccessor;
+            _mapper = mapper;
+        }
+
+        public IEnumerable<BookmarkDTO> GetAll(bool showHidden = false)
+        {
+            var currentUserId = GetCurrentUserId();
+            var userBookmarkDTOs = new List<BookmarkDTO>();
+
+
+            var showHiddenCondition = new Func<Bookmark, bool>(b => b.IsHidden || b.BookmarkTags.Where(x => x.Tag.UserId == currentUserId).Any(x => x.Tag.IsHidden));
+            var showNotHiddenCondition = new Func<Bookmark, bool>(b => !b.IsHidden && b.BookmarkTags.Where(x => x.Tag.UserId == currentUserId).All(bt => !bt.Tag.IsHidden));
+
+            var filteredBookmarks = _roContext.Bookmarks
+                .Include(b => b.BookmarkTags)
+                .ThenInclude(bt => bt.Tag)
+                .Where(b => b.UserId == currentUserId)
+                .Where(showHidden ? showHiddenCondition : showNotHiddenCondition)
+                .ToList();
+
+            foreach(var bookmark in filteredBookmarks)
+            {
+                var isBookmarkHidden = bookmark.IsHidden;
+                var bookmarkDTO = _mapper.Map<BookmarkDTO>(bookmark);
+                
+                var bookmarkTags = bookmark.BookmarkTags.Select(x => x.Tag);
+                bookmarkDTO.Tags = _mapper.Map<List<TagDTO>>(bookmarkTags);
+
+                userBookmarkDTOs.Add(bookmarkDTO);
+            }
+
+            return userBookmarkDTOs;
+        }
+
+        public async Task<BookmarkDTO?> CreateBookmark(CreateBookmarkRequestDTO request)
+        {
+            var currentUserId = GetCurrentUserId();
+
+            if (!_roContext.Users.UserExists(currentUserId)
+                || await _roContext.Bookmarks.AnyAsync(x => x.UserId == currentUserId && x.Url == request.Url)) return null;
+
+            var bookmark = _mapper.Map<Bookmark>(request);
+            UpdateBookmarkWithMetaData(bookmark);
+            bookmark.UserId = currentUserId;
+
+            var newEntity = await _context.Bookmarks.AddAsync(bookmark);
+
+            if (await _context.SaveChangesAsync() > 0)
+            {
+                var bookmarkDTO = _mapper.Map<BookmarkDTO>(newEntity.Entity);
+
+                if(request.Tags != null && request.Tags.Any())
+                    bookmarkDTO.Tags.AddRange(await UpdateBookmarkTags(bookmarkDTO.Id, request.Tags));
+                return bookmarkDTO;
+            }
+
+            return null;
+        }
+
+        public async Task<BookmarkDTO?> UpdateBookmark(int id, UpdateBookmarkRequestDTO request)
+        {
+            var currentUserId = GetCurrentUserId();
+
+            var bookmark = _context.Bookmarks.FirstOrDefault(x => x.UserId == currentUserId && x.Id == id);
+            var tags = new List<TagDTO>();
+
+            if (request.Tags != null && request.Tags.Any())
+                tags = (await UpdateBookmarkTags(id, request.Tags)).ToList();
+
+
+            if (bookmark == null) return null;
+
+            bookmark.Title = !string.IsNullOrEmpty(request.Title) ? request.Title : bookmark.Title;
+            bookmark.Description = !string.IsNullOrEmpty(request.Description) ? request.Description : bookmark.Description;
+            bookmark.Note = !string.IsNullOrEmpty(request.Note) ? request.Note : bookmark.Note;
+            bookmark.IsHidden = request.IsHidden;
+            bookmark.Url = !string.IsNullOrEmpty(request.Url) ? request.Url : bookmark.Url;
+            UpdateBookmarkWithMetaData(bookmark);
+
+            await _context.SaveChangesAsync();
+            var bookmarkDTO = _mapper.Map<BookmarkDTO>(bookmark);
+            bookmarkDTO.Tags = tags;
+            return bookmarkDTO;
+        }
+
+        public async Task<IEnumerable<TagDTO>?> UpdateBookmarkTags(int id, IEnumerable<string> tags)
+        {
+            var currentUserId = GetCurrentUserId();
+
+            if (!_roContext.Bookmarks.Any(x => x.Id == id && x.UserId == currentUserId)
+                 || tags == null || !tags.Any()) return null;
+
+            // Add tags that are not yet in the database
+            var savedUserTags = _context.Tags.Where(x => x.UserId == currentUserId).ToList();
+            var tagsToSave = tags.Except(savedUserTags.Select(x => x.Name).ToHashSet()).Select(x => new Tag { Name = x, UserId = currentUserId }).ToList();
+            await _context.Tags.AddRangeAsync(tagsToSave);
+            await _context.SaveChangesAsync();
+
+            // Add newly added tags to the lookup
+            savedUserTags.AddRange(tagsToSave);
+
+            var existingBookmarkTags = _roContext.BookmarkTags.Include(x => x.Tag).Where(x => x.BookmarkId == id).ToList();
+            var existingBookmarkTagsLookup = existingBookmarkTags.ToDictionary(k => k.TagId, v => v.Tag.Name);
+
+            var bookmarkTagsToRemove = existingBookmarkTagsLookup
+                .Where(x => !tags.Contains(x.Value))
+                .Select(x => new BookmarkTag { BookmarkId = id, TagId = x.Key });
+
+            var savedUserTagsByName = savedUserTags.ToDictionary(k => k.Name, v => v.Id);
+            var bookmarkTagsToAdd = tags.Except(existingBookmarkTagsLookup.Values)
+                .Select(x => new BookmarkTag { BookmarkId = id, TagId = savedUserTagsByName[x] });
+
+            _context.BookmarkTags.RemoveRange(bookmarkTagsToRemove);
+            await _context.BookmarkTags.AddRangeAsync(bookmarkTagsToAdd);
+
+            if (await _context.SaveChangesAsync() >= 0)
+            {
+                var updatedBookmarkTags = _roContext.BookmarkTags
+                    .Include(x => x.Tag)
+                    .Where(x => x.BookmarkId == id)
+                    .Select(x => x.Tag);
+
+                return _mapper.Map<IEnumerable<TagDTO>>(updatedBookmarkTags);
+            }
+
+            return null;
+        }
+
+        public async Task<BookmarkDTO?> Get(int id)
+        {
+            int.TryParse(_httpContextAccessor.HttpContext.User.Identity.GetUserId(), out int userId);
+            var bookmark = await _roContext.Bookmarks.FirstOrDefaultAsync(x => x.Id == id && x.UserId == userId);
+
+            if (bookmark == null) return null;
+
+            var bookmarkTags = _roContext.BookmarkTags
+                .Include(x => x.Tag)
+                .Where(x => x.BookmarkId == id)
+                .Select(x => x.Tag)
+                .ToList();
+
+            var bookmarkDTO = _mapper.Map<BookmarkDTO>(bookmark);
+            bookmarkDTO.Tags = _mapper.Map<List<TagDTO>>(bookmarkTags);
+
+            return bookmarkDTO;
+        }
+
+        public IEnumerable<TagDTO>? GetBookmarkTags(int id)
+        {
+            int.TryParse(_httpContextAccessor.HttpContext.User.Identity.GetUserId(), out int userId);
+            if (!_roContext.Bookmarks.Any(x => x.Id == id && x.UserId == userId)) return null;
+
+            var bookmarkTags = _roContext.BookmarkTags
+                .Include(x => x.Tag)
+                .Where(x => x.BookmarkId == id)
+                .Select(x => x.Tag)
+                .ToList();
+
+            return _mapper.Map<IEnumerable<TagDTO>>(bookmarkTags);
+        }
+
+        public async Task<int?> DeleteBookmark(int id)
+        {
+            var result = await DeleteBookmarks(new List<int> { id });
+            return result.FirstOrDefault();
+        }
+
+        public async Task<IEnumerable<int>?> DeleteBookmarks(IEnumerable<int> ids)
+        {
+            var currentUserId = GetCurrentUserId();
+
+            if (!await _roContext.Users.UserExistsAsync(currentUserId)) return null;
+
+            var entriesToDelete = _context.Bookmarks.Where(x => x.UserId == currentUserId && ids.Contains(x.Id)).ToList();
+            _context.Bookmarks.RemoveRange(entriesToDelete);
+
+            if (await _context.SaveChangesAsync() <= 0) return null;
+
+            return entriesToDelete.Select(x => x.Id);
+        }
+
+        public async Task<IEnumerable<int>?> HideBookmarks(IEnumerable<int> ids)
+        {
+            var currentUserId = GetCurrentUserId();
+
+            if (!await _roContext.Users.UserExistsAsync(currentUserId)) return null;
+
+            var entriesToHide = _context.Bookmarks.Where(x => x.UserId == currentUserId && ids.Contains(x.Id)).ToList();
+            entriesToHide.ForEach((x) => { x.IsHidden = !x.IsHidden; });
+
+            if(await _context.SaveChangesAsync() <= 0) return null;
+
+            return entriesToHide.Select(x => x.Id);
+        }
+
+        public IEnumerable<TagDTO> GetAllBookmarkTags(bool showHidden = false)
+        {
+            var currentUserId = GetCurrentUserId();
+
+            var activeUserTags = _roContext.BookmarkTags
+                .Include(x => x.Tag)
+                .Where(x => x.Tag.UserId == currentUserId && x.Tag.IsHidden == showHidden)
+                .ToList()
+                .GroupBy(x => x.Tag.Id)
+                .Select(g => g.First()?.Tag);
+
+            return _mapper.Map<IEnumerable<TagDTO>>(activeUserTags);
+        }
+
+        private int GetCurrentUserId()
+        {
+            int.TryParse(_httpContextAccessor.HttpContext.User.Identity.GetUserId(), out int userId);
+            return userId;
+        }
+
+        private void UpdateBookmarkWithMetaData(IBookmark bookmark)
+        {
+            var webClient = new WebClient();
+            webClient.Headers.Add("User-Agent", "APIClient");
+            var sourceData = webClient.DownloadString(bookmark.Url);
+            var title = Regex.Match(sourceData, @"\<title\b[^>]*\>\s*(?<Title>[\s\S]*?)\</title\>", RegexOptions.IgnoreCase).Groups["Title"].Value;
+            var description = string.Empty;
+
+            var getHtmlDoc = new HtmlWeb();
+            var document = getHtmlDoc.Load(bookmark.Url);
+            var metaTags = document.DocumentNode.SelectNodes("//meta");
+            if (metaTags != null)
+            {
+                foreach (var sitetag in metaTags)
+                {
+                    if (sitetag.Attributes["name"] != null && sitetag.Attributes["content"] != null && sitetag.Attributes["name"].Value == "description")
+
+                    {
+
+                        description = sitetag.Attributes["content"].Value;
+                    }
+                }
+            }
+
+            bookmark.Title = !string.IsNullOrEmpty(bookmark.Title) ? bookmark.Title : string.IsNullOrEmpty(title) ? bookmark.Url : title;
+            bookmark.Description = !string.IsNullOrEmpty(bookmark.Description) ? bookmark.Description : description;
+        }
+    }
+}