aswi20220x00-gitlab/Backend/Core/ZipUtils/Export.cs @ a35cb648

using Core.Entities;
using Models.Enums;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Core.ZipUtils
{
    /// <summary>
    /// Static methods for database exporting
    /// </summary>
    public class Export
    {
        /// <summary>
        /// Exports the specified annotations
        /// </summary>
        /// <param name="documents">list of documents to export</param>
        /// <param name="documentAnnotations">document-annotations to export mapping</param>
        /// <param name="documentFinalAnnotations">document-final annotations to export mapping</param>
        /// <param name="annotationTags">annotation-annotation tags mapping</param>
        /// <param name="finalAnnotationTags">final annotation-final annotation tags mapping</param>
        /// <returns></returns>
        public static MemoryStream FullExport(List<Document> documents, Dictionary<Document, List<Annotation>> documentAnnotations, Dictionary<Document, FinalAnnotation> documentFinalAnnotations,
            Dictionary<Annotation, List<AnnotationTag>> annotationTags, Dictionary<FinalAnnotation, List<FinalAnnotationTag>> finalAnnotationTags)
        {
            MemoryStream ms = new MemoryStream();
            // Set keepOpen to true so that Dispose() does not close the MemoryStream
            var archive = new ZipArchive(ms, ZipArchiveMode.Create, true);

            for (int docIndex = 0; docIndex < documents.Count; docIndex++)
            {
                var document = documents[docIndex];
                string documentDir = $"{docIndex:00000}";

                // Write document content and name into a JSON file
                string documentInfoJson = DumpDocument(document);
                CreateFile(documentDir + "/document.json", documentInfoJson, archive);

                // Deal with annotations
                var annotations = documentAnnotations[document];
                for (int annotationIndex = 0; annotationIndex < annotations.Count; annotationIndex++)
                {
                    var annotation = annotations[annotationIndex];
                    var tags = annotationTags[annotation].Select(at => at as AnnotationTagGeneric).ToList();
                    string annotationInfoJson = DumpAnnotation(annotation, tags, document.Id);
                    CreateFile(documentDir + $"/annotation_{annotationIndex:00000}.json", annotationInfoJson, archive);
                }

                // Deal with final annotation if it exists
                var finalAnnotation = documentFinalAnnotations[document];
                if (finalAnnotation == null)
                {
                    continue;
                }

                var finalTags = finalAnnotationTags[finalAnnotation].Select(ft => ft as AnnotationTagGeneric).ToList();
                string finalAnnotationInfoJson = DumpAnnotation(finalAnnotation, finalTags, document.Id);
                CreateFile(documentDir + "/final.json", finalAnnotationInfoJson, archive);
            }

            // Dispose of archive to close the header
            archive.Dispose();
            ms.Position = 0;
            return ms;
        }

        /// <summary>
        /// Creates a file and writes to it
        /// </summary>
        /// <param name="path">path to file</param>
        /// <param name="fileContent">string to write</param>
        /// <param name="archive">archive to write it to</param>
        private static void CreateFile(string path, string fileContent, ZipArchive archive)
        {
            var entry = archive.CreateEntry(path);
            var entryStream = entry.Open();
            entryStream.Write(Encoding.UTF8.GetBytes(fileContent));
            entryStream.Close();
        }

        /// <summary>
        /// Dumps a Document into JSON-serialized ExportDocumentInfo
        /// </summary>
        /// <param name="document">Document to serialize</param>
        /// <returns>JSON-serialized ExportDocumentInfo</returns>
        private static string DumpDocument(Document document)
        {
            ExportDocumentInfo documentInfo = new();
            documentInfo.Name = document.Name;
            documentInfo.Content = document.Content.Content;
            documentInfo.DocumentId = document.Id;

            return JsonConvert.SerializeObject(documentInfo);
        }

        /// <summary>
        /// Dumps annotation into JSON-serialized ExportAnnotationInfo
        /// </summary>
        /// <param name="annotation">Annotation to dump</param>
        /// <param name="tags">Tags related to the annotation</param>
        /// <param name="documentId">Id of the document the annotation is related to</param>
        /// <returns>JSON-serialized ExportAnnotationInfo</returns>
        private static string DumpAnnotation(Annotation annotation, List<AnnotationTagGeneric> tags, Guid documentId)
        {
            ExportAnnotationInfo annotationInfo = new();
            annotationInfo.AnnotatorId = annotation.User.Id;
            annotationInfo.DocumentId = documentId;

            foreach (var tag in tags)
            {
                ExportTagInstanceInfo tagInfo = new()
                {

                    Category = tag.Tag.Category.Name,
                    TagName = tag.Tag.Name,
                    InstanceId = tag.Instance,
                    FirstCharPosition = tag.Position,
                    Length = tag.Length,
                };

                if (tag.Tag.SentimentEnabled && tagInfo.Sentiment != null)
                {
                    tagInfo.Sentiment = tag.Sentiment.ToString().ToLower();
                }

                if (tag.SubTag != null)
                {
                    tagInfo.SubTagName = tag.SubTag.Name;
                }

                annotationInfo.Tags.Add(tagInfo);
            }

            return JsonConvert.SerializeObject(annotationInfo);
        }
    }

    public class ExportDocumentInfo
    {
        /// <summary>
        /// Document name
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// Original document content
        /// </summary>
        public string Content { get; set; }
        /// <summary>
        /// Id of the document
        /// </summary>
        public Guid DocumentId { get; set; }
    }

    public class ExportAnnotationInfo
    {
        /// <summary>
        /// Annotator Id
        /// </summary>
        public Guid AnnotatorId { get; set; }
        /// <summary>
        /// Document Id
        /// </summary>
        public Guid DocumentId { get; set; }
        /// <summary>
        /// Tags 
        /// </summary>
        public List<ExportTagInstanceInfo> Tags { get; set; } = new();
    }

    public class ExportTagInstanceInfo
    {
        /// <summary>
        /// Tag category
        /// </summary>
        public string Category { get; set; }
        /// <summary>
        /// Name of the tag (the primary identifier)
        /// </summary>
        public string TagName { get; set; }
        /// <summary>
        /// Name of the subtag (the primary identifier of a subtag)
        /// </summary>
        public string? SubTagName { get; set; }
        /// <summary>
        /// Id of the instance (in case of multipart tags multiple tags share the same Id)
        /// </summary>
        public Guid InstanceId { get; set; }
        /// <summary>
        /// Position in the original document
        /// </summary>
        public int FirstCharPosition { get; set; }
        /// <summary>
        /// Length of the section in chars
        /// </summary>
        public int Length { get; set; }
        /// <summary>
        /// Optional sentiment
        /// </summary>
        public string? Sentiment { get; set; }
    }
}