Implement all LIFT import fields for better protection (#3531)

Author: imnasnainaec

Backend.Tests/Helper/LiftHelperTests.cs

@@ -27,6 +27,10 @@ public void EntryUnprotected()
             entry.Notes.Add(new("", new("key", "content")));
             entry.Pronunciations.Add(new());
             entry.Pronunciations.Add(new());
+            foreach (var pronunciation in entry.Pronunciations)
+            {
+                pronunciation.Media.Add(new() { Url = "file://path" });
+            }
             entry.Senses.Add(new());
             entry.Senses.Add(new());
             // The only entry trait not protected is morph type "stem".
@@ -99,6 +103,18 @@ public void EntryNotesProtected()
             Assert.That(reasons.Last().Type, Is.EqualTo(ReasonType.Notes));
         }
 
+        [Test]
+        public void EntryPronunciationWithoutUrlProtected()
+        {
+            var entry = new LiftEntry();
+            entry.Pronunciations.Add(new());
+            entry.Pronunciations.Add(new());
+            Assert.That(IsProtected(entry), Is.True);
+            var reasons = GetProtectedReasons(entry);
+            Assert.That(reasons, Has.Count.EqualTo(1));
+            Assert.That(reasons.Last().Type, Is.EqualTo(ReasonType.PronunciationWithoutUrl));
+        }
+
         [Test]
         public void EntryRelationsProtected()
         {

Backend/Helper/LiftHelper.cs

@@ -76,8 +76,9 @@ public static string GetLiftRootFromExtractedZip(string dirPath)
         public static bool IsProtected(LiftEntry entry)
         {
             return entry.Annotations.Count > 0 || entry.Etymologies.Count > 0 || entry.Fields.Count > 0 ||
-                (entry.Notes.Count == 1 && !string.IsNullOrEmpty(entry.Notes.First().Type)) ||
-                entry.Notes.Count > 1 || entry.Relations.Count > 0 ||
+                (entry.Notes.Count == 1 && !string.IsNullOrEmpty(entry.Notes.First().Type)) || entry.Notes.Count > 1 ||
+                entry.Pronunciations.Any(p => p.Media.All(m => string.IsNullOrEmpty(m.Url))) ||
+                entry.Relations.Count > 0 ||
                 entry.Traits.Any(t => !t.Value.Equals("stem", StringComparison.OrdinalIgnoreCase) ||
                     !t.Name.Replace("-", "").Equals(TraitNames.MorphType, StringComparison.OrdinalIgnoreCase)) ||
                 entry.Variants.Count > 0;
@@ -107,6 +108,10 @@ public static List<ProtectReason> GetProtectedReasons(LiftEntry entry)
             {
                 reasons.Add(new() { Type = ReasonType.Notes, Count = entry.Notes.Count });
             }
+            if (entry.Pronunciations.Any(p => p.Media.All(m => string.IsNullOrEmpty(m.Url))))
+            {
+                reasons.Add(new() { Type = ReasonType.PronunciationWithoutUrl });
+            }
             if (entry.Relations.Count > 0)
             {
                 reasons.Add(new() { Type = ReasonType.Relations, Count = entry.Relations.Count });

Backend/Models/ProtectReason.cs

@@ -15,6 +15,7 @@ public enum ReasonType
         Illustrations,
         NoteWithType,
         Notes,
+        PronunciationWithoutUrl,
         Relations,
         Reversals,
         Subsenses,

Backend/Services/LiftService.cs

@@ -340,7 +340,7 @@ public async Task<string> LiftExport(
                 if (src is null || !File.Exists(src))
                 {
                     continue;
-                };
+                }
 
                 var safeName = Sanitization.MakeFriendlyForPath(speaker.Name);
                 var fileName = safeName == "" ? Path.GetFileNameWithoutExtension(src) : safeName;
@@ -549,7 +549,7 @@ private static async Task AddAudio(LexEntry entry, List<Pronunciation> pronuncia
                 if (!File.Exists(src))
                 {
                     continue;
-                };
+                }
 
                 var dest = Path.Combine(path, audio.FileName);
                 if (Path.GetExtension(dest).Equals(".webm", StringComparison.OrdinalIgnoreCase))
@@ -865,10 +865,16 @@ public void FinishEntry(LiftEntry entry)
                 // Only add audio if the files exist
                 if (Directory.Exists(extractedAudioDir))
                 {
-                    foreach (var pro in entry.Pronunciations)
+                    foreach (var pronunciation in entry.Pronunciations)
                     {
-                        // Add audio with Protected = true to prevent modifying or deleting imported audio
-                        newWord.Audio.Add(new Pronunciation(pro.Media.First().Url) { Protected = true });
+                        foreach (var media in pronunciation.Media)
+                        {
+                            if (!string.IsNullOrEmpty(media.Url))
+                            {
+                                // Add audio with Protected = true to prevent modifying or deleting imported audio
+                                newWord.Audio.Add(new(media.Url) { Protected = true });
+                            }
+                        }
                     }
                 }
 
@@ -879,47 +885,44 @@ public void FinishEntry(LiftEntry entry)
             /// <summary> Creates the object to transfer all the data from a word </summary>
             public LiftEntry GetOrMakeEntry(Extensible info, int order)
             {
-                return new LiftEntry(info, info.Guid, order)
-                {
-                    LexicalForm = new LiftMultiText(),
-                    CitationForm = new LiftMultiText()
-                };
+                return new LiftEntry(info, info.Guid, order) { CitationForm = [], LexicalForm = [] };
             }
 
             /// <summary> Creates an empty sense object and adds it to the entry </summary>
             public LiftSense GetOrMakeSense(LiftEntry entry, Extensible info, string rawXml)
             {
-                var sense = new LiftSense(info, info.Guid, entry)
-                {
-                    Definition = new LiftMultiText(),
-                    Gloss = new LiftMultiText()
-                };
+                var sense = new LiftSense(info, info.Guid, entry) { Definition = [], Gloss = [] };
                 entry.Senses.Add(sense);
                 return sense;
             }
 
             /// <summary> Adds each citation form to the entry for the vernacular </summary>
             public void MergeInCitationForm(LiftEntry entry, LiftMultiText contents)
             {
+                entry.CitationForm ??= [];
                 foreach (var (key, value) in contents)
                 {
                     entry.CitationForm.Add(key, value.Text);
                 }
             }
 
             /// <summary> Adds field to the entry for plural forms </summary>
-            public void MergeInField(LiftObject extensible, string typeAttribute, DateTime dateCreated,
+            public void MergeInField(LiftObject extensible, string tagAttribute, DateTime dateCreated,
                 DateTime dateModified, LiftMultiText contents, List<Trait> traits)
             {
-                var textEntry = new LiftMultiText(contents.FirstValue.Key,
-                    contents.FirstValue.Value.Text);
-                var fieldEntry = new LiftField(typeAttribute, textEntry);
-                extensible.Fields.Add(fieldEntry);
+                var field = new LiftField(tagAttribute, contents)
+                {
+                    DateCreated = dateCreated,
+                    DateModified = dateModified,
+                };
+                field.Traits.AddRange(traits.Select(t => new LiftTrait() { Name = t.Name, Value = t.Value }));
+                extensible.Fields.Add(field);
             }
 
             /// <summary> Adds sense's definitions to the entry. </summary>
             public void MergeInDefinition(LiftSense sense, LiftMultiText multiText)
             {
+                sense.Definition ??= [];
                 foreach (var (key, value) in multiText)
                 {
                     sense.Definition.Add(key, value.Text);
@@ -929,6 +932,7 @@ public void MergeInDefinition(LiftSense sense, LiftMultiText multiText)
             /// <summary> Adds sense's glosses to the entry. </summary>
             public void MergeInGloss(LiftSense sense, LiftMultiText multiText)
             {
+                sense.Gloss ??= [];
                 foreach (var (key, value) in multiText)
                 {
                     sense.Gloss.Add(key, value.Text);
@@ -938,6 +942,7 @@ public void MergeInGloss(LiftSense sense, LiftMultiText multiText)
             /// <summary> Adds each lexeme form to the entry for the vernacular </summary>
             public void MergeInLexemeForm(LiftEntry entry, LiftMultiText contents)
             {
+                entry.LexicalForm ??= [];
                 foreach (var (key, value) in contents)
                 {
                     entry.LexicalForm.Add(key, value);
@@ -947,50 +952,52 @@ public void MergeInLexemeForm(LiftEntry entry, LiftMultiText contents)
             /// <summary> Adds field to the entry for semantic domains </summary>
             public void MergeInTrait(LiftObject extensible, Trait trait)
             {
-                extensible.Traits.Add(new LiftTrait { Name = trait.Name, Value = trait.Value });
+                extensible.Traits.Add(new() { Name = trait.Name, Value = trait.Value });
             }
 
             /// <summary> Needs to be called before MergeInMedia </summary>
             public LiftObject MergeInPronunciation(LiftEntry entry, LiftMultiText contents, string rawXml)
             {
-                return entry;
+                var pronunciation = new LiftPhonetic { Form = contents };
+                entry.Pronunciations.Add(pronunciation);
+                return pronunciation;
             }
 
             /// <summary> Adds in media for audio pronunciation </summary>
             public void MergeInMedia(LiftObject pronunciation, string href, LiftMultiText caption)
             {
-                var entry = (LiftEntry)pronunciation;
-                var phonetic = new LiftPhonetic();
-                var url = new LiftUrlRef { Url = href, Label = caption };
-                phonetic.Media.Add(url);
-                entry.Pronunciations.Add(phonetic);
+                (pronunciation as LiftPhonetic)?.Media.Add(new() { Label = caption, Url = href });
             }
 
             /// <summary> Adds in note, if there is one to add </summary>
             public void MergeInNote(LiftObject extensible, string type, LiftMultiText contents, string rawXml)
             {
+                var note = new LiftNote(type, contents);
                 if (extensible is LiftEntry entry)
                 {
-                    var note = new LiftNote(
-                        // This application only uses "basic" notes, which have no type
-                        null,
-                        new LiftMultiText(contents.FirstValue.Key, contents.FirstValue.Value.Text));
                     entry.Notes.Add(note);
                 }
+                else if (extensible is LiftSense sense)
+                {
+                    sense.Notes.Add(note);
+                }
+                else if (extensible is LiftExample example)
+                {
+                    example.Notes.Add(note);
+                }
             }
 
-            public void MergeInGrammaticalInfo(LiftObject senseOrReversal, string val, List<Trait> traits)
+            public void MergeInGrammaticalInfo(LiftObject obj, string val, List<Trait> traits)
             {
-                if (senseOrReversal is LiftSense sense)
+                var gramInfo = new LiftGrammaticalInfo { Value = val };
+                gramInfo.Traits.AddRange(traits.Select(t => new LiftTrait { Name = t.Name, Value = t.Value }));
+                if (obj is LiftSense sense)
                 {
-                    if (sense.GramInfo is null)
-                    {
-                        sense.GramInfo = new LiftGrammaticalInfo { Value = val };
-                    }
-                    else
-                    {
-                        sense.GramInfo.Value = val;
-                    }
+                    sense.GramInfo = gramInfo;
+                }
+                else if (obj is LiftReversal reversal)
+                {
+                    reversal.GramInfo = gramInfo;
                 }
             }
 
@@ -1024,60 +1031,113 @@ public void ProcessRangeElement(string range, string id, string guid, string par
                 }
             }
 
-            // The following are unused and are not implemented, but may still be called by the Lexicon Merger
-            // They may be useful later if we need to add more complex attributes to words in The Combine
+            // The following may be called by the Lexicon Merger.
+            // We don't use this info in The Combine except to know when to protect imported data.
             [ExcludeFromCodeCoverage]
             public LiftExample GetOrMakeExample(LiftSense sense, Extensible info)
             {
-                return new LiftExample { Content = new LiftMultiText() };
+                var example = new LiftExample
+                {
+                    DateCreated = info.CreationTime,
+                    DateModified = info.ModificationTime,
+                    Guid = info.Guid,
+                    Id = info.Id
+                };
+                sense.Examples.Add(example);
+                return example;
             }
+
             [ExcludeFromCodeCoverage]
             public LiftObject GetOrMakeParentReversal(LiftObject parent, LiftMultiText contents, string type)
             {
-                return new LiftReversal();
+                return new LiftReversal { Form = contents, Main = parent as LiftReversal, Type = type };
             }
+
             [ExcludeFromCodeCoverage]
             public LiftSense GetOrMakeSubsense(LiftSense sense, Extensible info, string rawXml)
             {
-                return new LiftSense(info, new Guid(), sense)
-                {
-                    Definition = new LiftMultiText(),
-                    Gloss = new LiftMultiText()
-                };
+                var subsense = new LiftSense(info, info.Guid, sense);
+                sense.Subsenses.Add(subsense);
+                return subsense;
             }
+
             [ExcludeFromCodeCoverage]
             public LiftObject MergeInEtymology(LiftEntry entry, string source, string type, LiftMultiText form,
                         LiftMultiText gloss, string rawXml)
             {
-                return new LiftEtymology();
+                var etymology = new LiftEtymology { Form = form, Gloss = gloss, Source = source, Type = type };
+                entry.Etymologies.Add(etymology);
+                return etymology;
             }
+
             [ExcludeFromCodeCoverage]
             public LiftObject MergeInReversal(
                         LiftSense sense, LiftObject parent, LiftMultiText contents, string type, string rawXml)
             {
-                return new LiftReversal();
+                var reversal = new LiftReversal { Form = contents, Main = parent as LiftReversal, Type = type };
+                sense.Reversals.Add(reversal);
+                return reversal;
             }
+
             [ExcludeFromCodeCoverage]
             public LiftObject MergeInVariant(LiftEntry entry, LiftMultiText contents, string rawXml)
             {
-                return new LiftVariant();
+                var variant = new LiftVariant { Form = contents, RawXml = rawXml };
+                entry.Variants.Add(variant);
+                return variant;
             }
+
             [ExcludeFromCodeCoverage]
-            public void EntryWasDeleted(Extensible info, DateTime dateDeleted) { }
-            [ExcludeFromCodeCoverage]
-            public void MergeInExampleForm(LiftExample example, LiftMultiText multiText) { }
+            public void MergeInExampleForm(LiftExample example, LiftMultiText multiText)
+            {
+                example.Content ??= [];
+                foreach (var (key, value) in multiText)
+                {
+                    example.Content.Add(key, value);
+                }
+            }
+
             [ExcludeFromCodeCoverage]
-            public void MergeInPicture(LiftSense sense, string href, LiftMultiText caption) { }
+            public void MergeInPicture(LiftSense sense, string href, LiftMultiText caption)
+            {
+                sense.Illustrations.Add(new() { Label = caption, Url = href });
+            }
+
             [ExcludeFromCodeCoverage]
             public void MergeInRelation(
                         LiftObject extensible, string relationTypeName, string targetId, string rawXml)
-            { }
+            {
+                var relation = new LiftRelation { Ref = targetId, Type = relationTypeName };
+                if (extensible is LiftEntry entry)
+                {
+                    entry.Relations.Add(relation);
+                }
+                else if (extensible is LiftSense sense)
+                {
+                    sense.Relations.Add(relation);
+                }
+                else if (extensible is LiftVariant variant)
+                {
+                    variant.Relations.Add(relation);
+                }
+            }
+
             [ExcludeFromCodeCoverage]
-            public void MergeInSource(LiftExample example, string source) { }
+            public void MergeInSource(LiftExample example, string source)
+            {
+                example.Source = source;
+            }
+
             [ExcludeFromCodeCoverage]
             public void MergeInTranslationForm(
-                        LiftExample example, string type, LiftMultiText multiText, string rawXml)
-            { }
+                        LiftExample example, string type, LiftMultiText contents, string rawXml)
+            {
+                example.Translations.Add(new() { Content = contents, Type = type });
+            }
+
+            // The following are unimplemented, but may still be called by the Lexicon Merger
+            [ExcludeFromCodeCoverage]
+            public void EntryWasDeleted(Extensible info, DateTime dateDeleted) { }
             [ExcludeFromCodeCoverage]
             public void ProcessFieldDefinition(string tag, LiftMultiText description) { }
         }

public/locales/en/translation.json

@@ -429,6 +429,7 @@
       "noteWithType": "note with type \"{{ val }}\"",
       "notesSense": "notes",
       "notesWord": "more than 1 note",
+      "pronunciationWithoutUrl": "pronunciation without a media file",
       "relations": "relations",
       "reversal": "\"{{ val }}\" reversal",
       "subsenses": "subsenses",

src/api/models/reason-type.ts

@@ -26,6 +26,7 @@ export enum ReasonType {
   Illustrations = "Illustrations",
   NoteWithType = "NoteWithType",
   Notes = "Notes",
+  PronunciationWithoutUrl = "PronunciationWithoutUrl",
   Relations = "Relations",
   Reversals = "Reversals",
   Subsenses = "Subsenses",