aswi20220x00-gitlab/Backend/Core/Services/AnnotationService/AnnotationServiceEF.cs @ f260dac8

using Core.Contexts;
using Core.Entities;
using Models.Annotations;
using Models.Enums;
using Serilog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using AutoMapper;
using Models.Tags;
using Ganss.XSS;
using HtmlAgilityPack;
using System.Text.RegularExpressions;
using Newtonsoft.Json;
using Core.GraphUtils;

namespace Core.Services.AnnotationService
{
    public class AnnotationServiceEF : IAnnotationService
    {
        private readonly DatabaseContext context;
        private readonly ILogger logger;
        private readonly IMapper mapper;
        private readonly IHTMLService htmlService;


        public AnnotationServiceEF(DatabaseContext context, ILogger logger, IMapper mapper, IHTMLService htmlService)
        {
            this.context = context;
            this.logger = logger;
            this.mapper = mapper;
            this.htmlService = htmlService;
        }

        public void CreateDocumentAnnotations(AnnotationsAddRequest request, Guid clientUserId)
        {
            User addingUser = context.Users.Single(u => u.Id == clientUserId);

            // Check the documents exist
            var documents = context.Documents.Where(d => request.DocumentIdList.Contains(d.Id)).ToList();
            if (documents.Count() != request.DocumentIdList.Count)
            {
                logger.Information($"Received a non-existent Document ID when assigning documents to users");
                throw new InvalidOperationException($"{request.DocumentIdList.Count - documents.Count()} of the received documents do not exist");
            }

            var users = context.Users.Where(u => request.UserIdList.Contains(u.Id)).ToList();
            foreach (var user in users)
            {
                var userAnnotatedDocuments = context.Annotations
                    .Where(a => !(a is FinalAnnotation))
                    .Where(a => a.User == user)
                    .Select(a => a.Document)
                    .ToList();
                foreach (var doc in documents)
                {
                    if (userAnnotatedDocuments.Contains(doc))
                    {
                        logger.Information($"User {user.Username} has already been assigned the document {doc.Id}, ignoring");
                        continue;
                    }

                    context.Annotations.Add(new Annotation()
                    {
                        User = user,
                        UserAssigned = addingUser,
                        DateAssigned = DateTime.Now,
                        DateLastChanged = DateTime.Now,
                        Document = doc,
                        State = EState.NEW,
                        Note = ""
                    });
                }
            }

            context.SaveChanges();
        }

        public AnnotationListResponse GetUserAnnotations(Guid userId)
        {
            var annotations = context.Annotations
                .Where(a => !(a is FinalAnnotation))
                .Where(a => a.User.Id == userId)
                .Include(a => a.Document)
                .ToList();

            var infos = new List<AnnotationListInfo>();
            foreach (var annotation in annotations)
            {
                infos.Add(new AnnotationListInfo()
                {
                    AnnotationId = annotation.Id,
                    DocumentName = annotation.Document.Name,
                    State = annotation.State
                });
            }

            return new AnnotationListResponse()
            {
                Annotations = infos
            };
        }

        public void AddNoteToAnnotation(Guid annotationId, Guid userId, ERole userRole, AddNoteToAnnotationRequest request, bool isFinal)
        {
            Annotation annotation = null;
            try
            {
                if (!isFinal)
                {
                    annotation = context.Annotations.Include(a => a.User).First(a => a.Id == annotationId);
                }
                else
                {
                    annotation = context.FinalAnnotations.Include(a => a.User).First(a => a.Id == annotationId);
                }
            }
            catch (Exception)
            {
                throw new InvalidOperationException("Annotation not found");
            }

            if (userRole < ERole.ADMINISTRATOR && annotation.User.Id != userId)
            {
                throw new UnauthorizedAccessException("User does not have access to this annotation");
            }

            annotation.Note = request.Note;
            context.SaveChanges();
        }


        public AnnotationInfo GetAnnotation(Guid annotationId, Guid userId, ERole userRole, bool isFinal)
        {
            Annotation annotation = new();
            if (!isFinal)
            {
                annotation = context.Annotations
                .Where(a => !(a is FinalAnnotation))
                .Where(a => a.Id == annotationId)
                .Include(a => a.User)
                .Include(a => a.Document).ThenInclude(d => d.Content)
                .First();
            }
            else
            {
                annotation = context.FinalAnnotations
                .Where(a => a.Id == annotationId)
                .Include(a => a.User)
                .Include(a => a.Document).ThenInclude(d => d.Content)
                .First();
            }


            if (userRole < ERole.ADMINISTRATOR)
            {
                if (annotation.User.Id != userId)
                {
                    throw new UnauthorizedAccessException($"User {userId} does not have assigned annotation {annotationId}");
                }
            }

            var documentContent = context.Documents.Where(d => d.Id == annotation.Document.Id).Select(d => d.Content).First();

            IQueryable<AnnotationTagGeneric> tagsQuery;
            List<AnnotationTagGeneric> tags;
            if (!isFinal)
            {
                tagsQuery = context.AnnotationTags.Where(at => at.Annotation.Id == annotationId);
            }
            else
            {
                tagsQuery = context.FinalAnnotationTags.Where(at => at.Annotation.Id == annotationId);
            }

            tags = tagsQuery.Include(at => at.Tag)
                .ThenInclude(t => t.Category)
                .Include(at => at.SubTag)
                .OrderBy(at => at.Position)
                .Select(at => at)
                .ToList();

            List<TagInstanceInfo> tagInstanceInfos = new();
            foreach (var tag in tags)
            {
                var tagInstance = mapper.Map<TagInstanceInfo>(tag);
                tagInstanceInfos.Add(tagInstance);
            }

            var docToRender = "";
            HTMLService.CachedInfo cachedInfoToReturn = new();
            if (annotation.CachedDocumentHTML == "")
            {
                var result = htmlService.FullPreprocessHTML(documentContent.Content, tags);
                cachedInfoToReturn = result.Item2;
                docToRender = result.Item1;

                annotation.CachedStartPositions = JsonConvert.SerializeObject(cachedInfoToReturn.TagStartPositions);
                annotation.CachedLengths = JsonConvert.SerializeObject(cachedInfoToReturn.TagStartLengths);
                annotation.CachedClosingPositions = JsonConvert.SerializeObject(cachedInfoToReturn.TagClosingPositions);
                annotation.CachedClosingLengths = JsonConvert.SerializeObject(cachedInfoToReturn.TagClosingLengths);
                annotation.CachedCSS = JsonConvert.SerializeObject(cachedInfoToReturn.TagInstanceCSS);
                annotation.ModifiedType = EModified.NONE;
                annotation.CachedDocumentHTML = docToRender;
                context.SaveChanges();
            }
            else
            {
                docToRender = annotation.CachedDocumentHTML;
                cachedInfoToReturn = new()
                {
                    TagStartPositions = JsonConvert.DeserializeObject<List<int>>(annotation.CachedStartPositions),
                    TagStartLengths = JsonConvert.DeserializeObject<List<int>>(annotation.CachedLengths),
                    TagClosingPositions = JsonConvert.DeserializeObject<List<int>>(annotation.CachedClosingPositions),
                    TagClosingLengths = JsonConvert.DeserializeObject<List<int>>(annotation.CachedClosingLengths),
                    TagInstanceCSS = JsonConvert.DeserializeObject<List<TagInstanceCSSInfo>>(annotation.CachedCSS)
                };

                // The annotation has been modified and we need to either add the new tag or remove the tag
                if (annotation.ModifiedType != EModified.NONE)
                {
                    if (annotation.ModifiedType == EModified.ADDED)
                    {

                        AnnotationTagGeneric lastModifiedTag = isFinal ? context.FinalAnnotationTags.Where(at => at.Id == annotation.LastModifiedTagId).First() : 
                            context.AnnotationTags.Where(at => at.Id == annotation.LastModifiedTagId).First();

                        var result = htmlService.PartialPreprocessHTMLAddTag(docToRender, documentContent.Content, lastModifiedTag, tags, cachedInfoToReturn);
                        docToRender = result.Item1;
                        cachedInfoToReturn = result.Item2;
                    }
                    else if (annotation.ModifiedType == EModified.REMOVED)
                    {
                        var result = htmlService.PartialPreprocessHTMLRemoveTag(docToRender, documentContent.Content, new AnnotationTag() { Id = annotation.LastModifiedTagId.Value }, tags, cachedInfoToReturn);
                        docToRender = result.Item1;
                        cachedInfoToReturn = result.Item2;
                    }

                    annotation.ModifiedType = EModified.NONE;
                    annotation.CachedStartPositions = JsonConvert.SerializeObject(cachedInfoToReturn.TagStartPositions);
                    annotation.CachedLengths = JsonConvert.SerializeObject(cachedInfoToReturn.TagStartLengths);
                    annotation.CachedClosingPositions = JsonConvert.SerializeObject(cachedInfoToReturn.TagClosingPositions);
                    annotation.CachedClosingLengths = JsonConvert.SerializeObject(cachedInfoToReturn.TagClosingLengths);
                    annotation.CachedDocumentHTML = docToRender;
                    annotation.CachedCSS = JsonConvert.SerializeObject(cachedInfoToReturn.TagInstanceCSS);
                    context.SaveChanges();
                }
            }

            // We probably cannot use AutoMapper since we are dealing with too many different entities
            AnnotationInfo annotationInfo = new()
            {
                SourceDocumentContent = documentContent.Content,
                DocumentToRender = docToRender,
                TagStartPositions = cachedInfoToReturn.TagStartPositions.ToArray(),
                TagLengths = cachedInfoToReturn.TagStartLengths.ToArray(),
                Note = annotation.Note,
                State = annotation.State,
                Type = IsHtml(documentContent.Content) ? EDocumentType.HTML : EDocumentType.TEXT,
                TagInstances = tagInstanceInfos,
                CSSInfo = cachedInfoToReturn.TagInstanceCSS
            };

            return annotationInfo;
        }

        // TODO temporary
        private bool IsHtml(string text)
        {
            return text.Contains("<html>");
        }

        public void AddAnnotationInstance(Guid annotationId, Guid userId, ERole userRole, AnnotationInstanceAddRequest request, bool isFinal)
        {
            Annotation annotation = new();
            if (!isFinal)
            {
                annotation = context.Annotations
                    .Where(a => !(a is FinalAnnotation))
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
            }
            else
            {
                annotation = context.FinalAnnotations
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
            }

            if (userRole < ERole.ADMINISTRATOR)
            {
                if (annotation.User.Id != userId)
                {
                    throw new UnauthorizedAccessException($"User {userId} does not have assigned annotation {annotationId}");
                }
            }

            if (annotation.State == EState.NEW)
            {
                annotation.State = EState.IN_PROGRESS;
            }

            AnnotationTagGeneric annotationTag = new();
            if (isFinal)
            {
                annotationTag = new FinalAnnotationTag()
                {
                    Id = Guid.NewGuid(),
                    Annotation = annotation as FinalAnnotation,
                    Instance = request.InstanceId == null ? Guid.NewGuid() : request.InstanceId.Value,
                    Length = request.Length,
                    Position = request.Position,
                    SelectedText = request.SelectedText,
                    Note = "",
                    IsFinal = true
                };
            }
            else
            {
                annotationTag = new AnnotationTag()
                {
                    Id = Guid.NewGuid(),
                    Annotation = annotation as Annotation,
                    Instance = request.InstanceId == null ? Guid.NewGuid() : request.InstanceId.Value,
                    Length = request.Length,
                    Position = request.Position,
                    SelectedText = request.SelectedText,
                    Note = ""
                };
            }

            if (request.Type == ETagType.TAG)
            {
                annotationTag.Tag = context.Tags.Where(t => t.Id == request.Id).Single();
                annotationTag.SubTag = null;

                if (annotationTag.Tag.SentimentEnabled)
                {
                    annotationTag.Sentiment = ETagSentiment.NEUTRAL;
                }

                // If for the same annotation exists a tag with same position and length and of the same type, ignore
                if (context.AnnotationTags.Any(at =>
                at.Position == annotationTag.Position &&
                at.Length == annotationTag.Length &&
                at.Annotation == annotation &&
                at.Tag == annotationTag.Tag))
                {
                    throw new InvalidOperationException("Duplicate tag");
                }

            }
            else if (request.Type == ETagType.SUBTAG)
            {
                var subTag = context.SubTags.Where(st => st.Id == request.Id).Include(st => st.Tag).Single();
                annotationTag.SubTag = subTag;
                annotationTag.Tag = subTag.Tag;

                if (annotationTag.SubTag.SentimentEnabled)
                {
                    annotationTag.Sentiment = ETagSentiment.NEUTRAL;
                }

                if (context.AnnotationTags.Any(at =>
                at.Position == annotationTag.Position &&
                at.Length == annotationTag.Length &&
                at.Annotation == annotation &&
                at.Tag == annotationTag.Tag &&
                at.SubTag == annotationTag.SubTag))
                {
                    throw new InvalidOperationException("Duplicate tag");
                }
            }
            else
            {
                throw new ArgumentException($"Unknown tag type {request.Type}");
            }

            if (annotation.State == EState.NEW)
            {
                annotation.State = EState.IN_PROGRESS;
            }

            annotation.LastModifiedTagId = annotationTag.Id;
            annotation.ModifiedType = EModified.ADDED;

            if (isFinal)
            {
                context.FinalAnnotationTags.Add(annotationTag as FinalAnnotationTag);
            }
            else
            {
                context.AnnotationTags.Add(annotationTag as AnnotationTag);
            }

            context.SaveChanges();
        }

        public void DeleteAnnotationInstance(Guid annotationId, Guid tagInstanceId, Guid loggedUserId, ERole userRole, bool isFinal)
        {
            Annotation annotation = null;
            try
            {
                if (!isFinal)
                {
                    annotation = context.Annotations
                    .Where(a => !(a is FinalAnnotation))
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
                }
                else
                {
                    annotation = context.FinalAnnotations
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
                }


            }
            catch (Exception ex)
            {
                throw new InvalidOperationException("Could not find annotation");
            }


            if (userRole < ERole.ADMINISTRATOR)
            {
                if (annotation.User.Id != loggedUserId)
                {
                    throw new UnauthorizedAccessException($"User {loggedUserId} does not have assigned annotation {annotationId}");
                }
            }

            AnnotationTagGeneric annotationTag = new();

            if (isFinal)
            {
                if (!context.FinalAnnotationTags.Any(at => at.Id == tagInstanceId))
                {
                    throw new InvalidOperationException("Could not find tag instance");
                }
                annotationTag = context.FinalAnnotationTags.First(at => at.Id == tagInstanceId);

            }
            else
            {
                if (!context.AnnotationTags.Any(at => at.Id == tagInstanceId))
                {
                    throw new InvalidOperationException("Could not find tag instance");
                }
                annotationTag = context.AnnotationTags.First(at => at.Id == tagInstanceId);
            }

            annotation.LastModifiedTagId = annotationTag.Id;
            annotation.ModifiedType = EModified.REMOVED;

            if (isFinal)
            {
                context.FinalAnnotationTags.Remove(annotationTag as FinalAnnotationTag);
            }
            else
            {
                context.AnnotationTags.Remove(annotationTag as AnnotationTag);
            }

            context.SaveChanges();
        }

        public void SetTagInstanceSentiment(Guid annotationId, Guid instanceId, Guid userId, ERole userRole, ETagSentiment sentiment, bool isFinal)
        {
            Annotation annotation = null;
            try
            {
                if (!isFinal)
                {
                    annotation = context.Annotations
                    .Where(a => !(a is FinalAnnotation))
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
                }
                else
                {
                    annotation = context.FinalAnnotations
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
                }
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException("Could not find annotation");
            }


            if (userRole < ERole.ADMINISTRATOR)
            {
                if (annotation.User.Id != userId)
                {
                    throw new UnauthorizedAccessException($"User {userId} does not have assigned annotation {annotationId}");
                }
            }


            IEnumerable<AnnotationTagGeneric> tagInstances = null;

            if (isFinal)
            {
                tagInstances = context.FinalAnnotationTags.Where(at => at.Instance == instanceId).ToList();
            }
            else
            {
                tagInstances = context.AnnotationTags.Where(at => at.Instance == instanceId).ToList();
            }

            if (tagInstances.Count() == 0)
            {
                throw new InvalidOperationException("No such instance found");
            }

            foreach (var tagInstance in tagInstances)
            {
                tagInstance.Sentiment = sentiment;
            }

            context.SaveChanges();
        }

        public void MarkAnnotationAsDone(Guid annotationId, Guid userId, ERole userRole, bool done, bool isFinal)
        {

            Annotation annotation = null;
            try
            {
                if (!isFinal)
                {
                    annotation = context.Annotations
                    .Where(a => !(a is FinalAnnotation))
                   .Where(a => a.Id == annotationId)
                   .Include(a => a.User)
                   .Include(a => a.Document).ThenInclude(d => d.Content)
                   .First();
                }
                else
                {
                    annotation = context.FinalAnnotations
                   .Where(a => a.Id == annotationId)
                   .Include(a => a.User)
                   .Include(a => a.Document).ThenInclude(d => d.Content)
                   .First();
                }
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException("Could not find annotation");
            }

            if (userRole < ERole.ADMINISTRATOR)
            {
                if (annotation.User.Id != userId)
                {
                    throw new UnauthorizedAccessException($"User {userId} does not have assigned annotation {annotationId}");
                }
            }

            annotation.State = done ? EState.DONE : EState.IN_PROGRESS;
            context.SaveChanges();
        }

        public Guid CreateFinalAnnotation(Guid documentId, Guid userId)
        {
            var document = context.Documents.Single(d => d.Id == documentId);
            var user = context.Users.Single(u => u.Id == userId);

            // Remove existing 
            if (context.FinalAnnotations.Any(fa => fa.Document == document))
            {
                var finalAnnotationOld = context.FinalAnnotations.Single(fa => fa.Document == document);
                context.FinalAnnotations.Remove(finalAnnotationOld);
            }

            var annotations = context.Annotations
                .Where(a => !(a is FinalAnnotation))
                .Include(a => a.Document)
                .Where(a => a.Document == document && a.State == EState.DONE)
                .ToList();

            var finalAnnotation = new FinalAnnotation()
            {
                Id = Guid.NewGuid(),
                DateAssigned = DateTime.Now,
                DateLastChanged = DateTime.Now,
                Document = document,
                User = user,
                UserAssigned = user,
                Annotations = annotations,
                State = EState.NEW
            };

            List<AnnotationTag> annotationTagsAll = new();
            foreach (var annotation in annotations)
            {
                annotationTagsAll.AddRange(context.AnnotationTags
                    .Where(at => at.Annotation == annotation)
                    .Include(at => at.Tag)
                    .Include(at => at.SubTag)
                    .Include(at => at.Annotation)
                    .ThenInclude(a => a.User)
                    .ToList());
            }
            annotationTagsAll = annotationTagsAll.OrderBy(at => at.Position).ToList();

            Dictionary<Guid, List<AnnotationTag>> occurenceDict = new();
            foreach (var annotationTag in annotationTagsAll)
            {
                if (occurenceDict.ContainsKey(annotationTag.Instance))
                {
                    occurenceDict[annotationTag.Instance].Add(annotationTag);
                }
                else
                {
                    occurenceDict[annotationTag.Instance] = new();
                    occurenceDict[annotationTag.Instance].Add(annotationTag);
                }
            }

            List<List<AnnotationTag>> occurenceLists = new();
            foreach (var key in occurenceDict.Keys)
            {
                occurenceLists.Add(occurenceDict[key]);
            }

            List<List<AnnotationTag>> annotationTagsProcessed = new();
            List<FinalAnnotationTag> finalAnnotationTags = new();
            for (int i = 0; i < occurenceLists.Count; i++)
            {
                var occurrenceList1 = occurenceLists[i];
                List<List<AnnotationTag>> sameLists = new();

                for (int j = 0; j < occurenceLists.Count; j++)
                {
                    var occurrenceList2 = occurenceLists[j];

                    if (annotationTagsProcessed.Contains(occurrenceList2))
                    {
                        continue;
                    }

                    if (SelectionsAreSame(occurrenceList1, occurrenceList2))
                    {
                        sameLists.Add(occurrenceList2);
                    }
                }

                // This means that this occurrence ahs already been processed as matching a previous tag
                if (sameLists.Count() == 0)
                {
                    continue;
                }

                List<User> relatedUsers = new();
                foreach (var list in sameLists)
                {
                    relatedUsers.Add(list[0].Annotation.User);
                }

                foreach (var tag in sameLists[0])
                {
                    finalAnnotationTags.Add(new()
                    {
                        Id = Guid.NewGuid(),
                        Tag = tag.Tag,
                        SubTag = tag.SubTag,
                        Annotation = finalAnnotation,
                        SelectedText = tag.SelectedText,
                        Sentiment = tag.Sentiment,
                        Instance = tag.Instance,
                        IsFinal = sameLists.Count == annotations.Count,
                        Length = tag.Length,
                        Position = tag.Position,
                        Note = "",
                        Users = relatedUsers
                    });
                }

                annotationTagsProcessed.AddRange(sameLists);
            }

            context.FinalAnnotations.Add(finalAnnotation);
            context.SaveChanges();
            context.FinalAnnotationTags.AddRange(finalAnnotationTags);

            context.SaveChanges();
            return finalAnnotation.Id;
        }

        private bool SelectionsAreSame(List<AnnotationTag> list1, List<AnnotationTag> list2)
        {
            if (list1.Count != list2.Count)
            {
                return false;
            }

            bool sentimentEnabled = list1[0].Tag.SentimentEnabled;

            if (sentimentEnabled)
            {
                for (int i = 0; i < list1.Count; i++)
                {
                    var tag1 = list1[i];
                    var tag2 = list2[i];
                    if (tag1.Position == tag2.Position &&
                        tag1.Length == tag2.Length &&
                        tag1.Sentiment == tag2.Sentiment &&
                        tag1.Tag == tag2.Tag &&
                        tag1.SubTag == tag2.SubTag)
                    {
                        continue;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else
            {
                for (int i = 0; i < list1.Count; i++)
                {
                    var tag1 = list1[i];
                    var tag2 = list2[i];
                    if (tag1.Position == tag2.Position &&
                        tag1.Length == tag2.Length &&
                        tag1.Tag == tag2.Tag &&
                        tag1.SubTag == tag2.SubTag)
                    {
                        continue;
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        public void SetTagIsFinal(Guid annotationId, Guid occurenceId, bool isFinal)
        {
            Annotation annotation;
            try
            {
                annotation = context.FinalAnnotations.Single(fa => fa.Id == annotationId);
            }
            catch (Exception)
            {
                throw new InvalidOperationException("Annotation not found");
            }

            FinalAnnotationTag finalTagInstance;
            try
            {
                finalTagInstance = context.FinalAnnotationTags.Single(fat => fat.Id == occurenceId);
            }
            catch (Exception)
            {
                throw new InvalidOperationException("Tag instance not found");
            }

            finalTagInstance.IsFinal = isFinal;

            context.SaveChanges();
        }
    }
}