aswi20220x00-gitlab/Backend/Core/Services/DocumentService/DocumentServiceEF.cs @ 02fc62a8

using Core.Contexts;
using Core.Entities;
using Models.Documents;
using Serilog;
using System;
using System.Collections.Generic;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using AutoMapper;
using Models.Users;
using Ganss.XSS;
using Microsoft.EntityFrameworkCore;

namespace Core.Services.DocumentService
{
    public class DocumentServiceEF : IDocumentService
    {
        private readonly DatabaseContext databaseContext;
        private readonly ILogger logger;
        private readonly IMapper mapper;

        public DocumentServiceEF(DatabaseContext databaseContext, ILogger logger, IMapper mapper)
        {
            this.databaseContext = databaseContext;
            this.logger = logger;
            this.mapper = mapper;
        }

        /// <summary>
        /// Adds the documents in request to the database
        /// </summary>
        /// <param name="request">request</param>
        /// <param name="userId">GUID of the user</param>
        /// <exception cref="InvalidOperationException">No User with passed GUID</exception>
        /// <exception cref="FormatException">Error decoding BASE64 content</exception>
        /// <exception cref="InvalidDataException">Zip file has wrong format</exception>
        /// <exception cref="IOException">Error reading entries from the zip file</exception>
        public void AddDocuments(DocumentAddRequest request, Guid userId)
        {
            User user = databaseContext.Users.Single(u => u.Id == userId);
            int requiredAnnotations = int.Parse(databaseContext.ConfigurationItems.Single(ci => ci.Key == Constants.Constants.RequiredAnnotationsKey).Value);

            foreach (var documentInfo in request.Documents)
            {
                if (documentInfo.Format == Models.Enums.EAddDocumentFormat.TEXTFILE)
                {
                    // TODO hardcoded UTF-8 - maybe do something smarter
                    var documentContent = Encoding.UTF8.GetString(Convert.FromBase64String(documentInfo.Content));
                    SaveDocument(documentContent, user, documentInfo.Name, requiredAnnotations);
                }
                else if (documentInfo.Format == Models.Enums.EAddDocumentFormat.ZIP)
                {
                    var (names, contents) = UnzipDocuments(documentInfo.Content);
                    for (int i = 0; i < names.Count; i++)
                    {
                        SaveDocument(contents[i], user, names[i], requiredAnnotations);
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="base64encoded"></param>
        /// <returns></returns>
        private (List<string> Names, List<string> Contents) UnzipDocuments(string base64encoded)
        {
            List<string> names = new();
            List<string> contents = new();

            byte[] decoded = Convert.FromBase64String(base64encoded);

            using (var zipStream = new MemoryStream(decoded))
            using (var zipArchive = new ZipArchive(zipStream))
            {
                foreach (var entry in zipArchive.Entries)
                {
                    names.Add(entry.Name);
                    using (var streamReader = new StreamReader(entry.Open()))
                    {
                        string text = streamReader.ReadToEnd();
                        contents.Add(text);
                    }
                }
            }

            return (names, contents);
        }

        private void SaveDocument(string content, User userAdded, string documentName, int requiredAnnotations)
        {
            DocumentContent documentContent = new DocumentContent()
            {
                Content = content
            };

            Document document = new Document()
            {
                DateAdded = DateTime.Now,
                Content = documentContent,
                UserAdded = userAdded,
                Name = documentName,
                Length = documentContent.Content.Length,
                RequiredAnnotations = requiredAnnotations
            };

            databaseContext.DocumentContents.Add(documentContent);
            databaseContext.Documents.Add(document);
            databaseContext.SaveChanges();
        }

        public DocumentListResponse GetDocuments(int pageIndex, int pageSize)
        {
            var firstIndex = pageIndex * pageSize;
            var documents = databaseContext.Documents.Select(d => d).ToList();
            var totalCount = documents.Count;
            var pageCount = totalCount / pageSize;
            if (pageCount == 0 && totalCount > 0)
            {
                pageCount = 1;
            }

            if (firstIndex > documents.Count - 1)
            {
                throw new Exception("Page index or page size too large");
            }

            if (firstIndex + pageSize > documents.Count - 1)
            {
                pageSize = documents.Count - firstIndex;
            }

            List<DocumentListInfo> documentInfos = new List<DocumentListInfo>();
            foreach (var document in documents.GetRange(firstIndex, pageSize))
            {
                var annotatingUsers = databaseContext.Annotations
                    .Where(a => !(a is FinalAnnotation))
                    .Where(a => a.Document == document)
                    .Select(a => a.User).ToList();

                List<DocumentUserInfo> annotatingUsersDto = new();

                // Include annotation state
                foreach (var annotatingUser in annotatingUsers)
                {
                    var annotation = databaseContext.Annotations
                        .Where(a => !(a is FinalAnnotation))
                        .Include(a => a.Document)
                        .Single(a => a.Document == document && a.User == annotatingUser && !(a is FinalAnnotation));
                    var dui = mapper.Map<DocumentUserInfo>(annotatingUser);
                    dui.State = annotation.State;
                    annotatingUsersDto.Add(dui);
                }

                DocumentListInfo dli = mapper.Map<DocumentListInfo>(document);
                dli.AnnotatingUsers = annotatingUsersDto;

                dli.FinalizedExists = databaseContext.FinalAnnotations.Any(fa => fa.Document == document);
                if (dli.FinalizedExists)
                {
                    var finalizedAnnotation = databaseContext.FinalAnnotations
                        .Include(fa => fa.Annotations)
                        .ThenInclude(a => a.User)
                        .Single(fa => fa.Document == document);
                    
                    dli.FinalizedAnnotationId = finalizedAnnotation.Id;
                    dli.FinalizedState = finalizedAnnotation.State;
                    dli.FinalAnnotations = new();

                    foreach (var annotation in finalizedAnnotation.Annotations)
                    {
                        dli.FinalAnnotations.Add(new()
                        {
                            AnnotationId = annotation.Id,
                            UserId = annotation.User.Id,
                            Username = annotation.User.Username,
                            UserFirstName = annotation.User.Name,
                            UserSurname = annotation.User.Surname,
                        });
                    }

                }

                documentInfos.Add(dli);
            }

            return new DocumentListResponse()
            {
                PageCount = pageCount,
                PageIndex = pageIndex,
                TotalCount = totalCount,
                Documents = documentInfos.OrderBy(di => di.Name).ToList()
            };
        }

        public void SetRequiredAnnotationsForDocuments(SetRequiredAnnotationsRequest request)
        {
            var documents = databaseContext.Documents.Where(d => request.DocumentIds.Contains(d.Id));
            foreach (var doc in documents)
            {
                doc.RequiredAnnotations = request.RequiredAnnotations;
            }
            databaseContext.SaveChanges();
        }

        public void SetRequiredAnnotationsGlobal(int requiredAnnotations)
        {
            var requiredAnnotationsItem = databaseContext.ConfigurationItems.Single(ci => ci.Key == Constants.Constants.RequiredAnnotationsKey);
            requiredAnnotationsItem.Value = requiredAnnotations.ToString();
            databaseContext.SaveChanges();
        }

        public int GetRequiredAnnotationsGlobal()
        {
            var requiredAnnotationsItem = databaseContext.ConfigurationItems.Single(ci => ci.Key == Constants.Constants.RequiredAnnotationsKey);
            return int.Parse(requiredAnnotationsItem.Value);
        }

        public DocumentPreviewResponse GetDocumentPreview(Guid documentId)
        {
            try
            {
                var document = databaseContext.Documents.Include(d => d.Content).Single(d => d.Id == documentId);
                HtmlSanitizer sanitizer = new HtmlSanitizer();
                sanitizer.AllowedAttributes.Clear();
                if (sanitizer.AllowedTags.Contains("img"))
                {
                    sanitizer.AllowedTags.Remove("img");
                }
                return new DocumentPreviewResponse()
                {
                    Content = sanitizer.Sanitize(document.Content.Content)
                };
            }
            catch (InvalidOperationException e)
            {
                throw new InvalidOperationException("Document not found");
            }
        }
    }
}