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

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;

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.Document == document).Select(a => a.User).ToList();
                List<UserInfo> annotatingUsersDto = annotatingUsers.Select(a => mapper.Map<UserInfo>(a)).ToList();

                DocumentListInfo dai = mapper.Map<DocumentListInfo>(document);
                dai.AnnotatingUsers = annotatingUsersDto;
                documentInfos.Add(dai);
            }

            return new DocumentListResponse()
            {
                PageCount = pageCount,
                PageIndex = pageIndex,
                TotalCount = totalCount,
                Documents = documentInfos
            };
        }

        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);
        }
    }
}