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

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
{
    public class Export
    {
        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();
            var archive = new ZipArchive(ms, ZipArchiveMode.Create);

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

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

            //archive.Dispose();
            ms.Position = 0;
            return ms;
        }

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

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

        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
    {
        public string Name { get; set; }
        public string Content { get; set; }
        public Guid DocumentId { get; set; }
    }

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

    public class ExportTagInstanceInfo
    {
        public string Category { get; set; }
        public string TagName { get; set; }
        public string? SubTagName { get; set; }
        public Guid InstanceId { get; set; }
        public int FirstCharPosition { get; set; }
        public int Length { get; set; }
        public string? Sentiment { get; set; }
    }
}