Prevent sorting by '-audio' citation and lexeme forms (#1807)

* [getSortableValue] Add types; Avoid audio lexeme forms
* Update getFontFamily... and test projects
* Also avoid audio citation forms

---------

Co-authored-by: Robin Munn <[email protected]>

Author: imnasnainaec

src/angular-app/bellows/core/offline/editor-data.service.ts

@@ -7,7 +7,9 @@ import {LexEntry} from '../../../languageforge/lexicon/shared/model/lex-entry.mo
 import {LexMultiValue} from '../../../languageforge/lexicon/shared/model/lex-multi-value.model';
 import {
   LexConfigFieldList,
+  LexConfigMultiOptionList,
   LexConfigMultiText,
+  LexConfigOptionList,
   LexiconConfig
 } from '../../../languageforge/lexicon/shared/model/lexicon-config.model';
 import {LexiconProjectSettings} from '../../../languageforge/lexicon/shared/model/lexicon-project-settings.model';
@@ -327,66 +329,68 @@ export class EditorDataService {
     return meaning || '';
   }
 
-  getSortableValue = (config: any, entry: any): string => {
+  getSortableValue = (config: LexiconConfig, entry: any): string => {
     const fieldKey = this.entryListModifiers.sortBy.value === 'default' ?
                       'lexeme' : this.entryListModifiers.sortBy.value;
     let sortableValue = '';
     let field;
     let dataNode;
     const isSpecialMultitext = (fieldKey === 'lexeme' || fieldKey === 'citationForm');
+    const sensesField = config.entry.fields.senses as LexConfigFieldList;
     if (fieldKey in config.entry.fields && fieldKey in entry) {
       field = config.entry.fields[fieldKey];
       dataNode = entry[fieldKey];
-    } else if (fieldKey in config.entry.fields.senses.fields && angular.isDefined(entry.senses) &&
+    } else if (fieldKey in sensesField.fields && angular.isDefined(entry.senses) &&
       entry.senses.length > 0 && fieldKey in entry.senses[0]
     ) {
-      field = config.entry.fields.senses.fields[fieldKey];
+      field = sensesField.fields[fieldKey];
       dataNode = entry.senses[0][fieldKey];
     }
 
     if (field || isSpecialMultitext) {
-      if (isSpecialMultitext || field.type === 'multitext') {
-        // special case for lexeme form / citation form. Use citation form if available, fall back to lexeme form
-        if (fieldKey === 'lexeme' || fieldKey === 'citationForm') {
-          if (config.entry.fields.citationForm) {
-            const citationFormInputSystems = config.entry.fields.citationForm.inputSystems;
-            if (entry.citationForm && citationFormInputSystems.length > 0 &&
-              citationFormInputSystems[0] in entry.citationForm
-            ) {
-              sortableValue = entry.citationForm[citationFormInputSystems[0]].value;
-            }
-          }
-
-          if (!sortableValue) {
-            const lexemeInputSystems = config.entry.fields.lexeme.inputSystems;
-            if (entry.lexeme && lexemeInputSystems.length > 0 && lexemeInputSystems[0] in entry.lexeme) {
-              sortableValue = entry.lexeme[lexemeInputSystems[0]].value;
-            }
+      // special case for lexeme form / citation form. Use citation form if available, fall back to lexeme form
+      if (isSpecialMultitext) {
+        if ('citationForm' in config.entry.fields) {
+          const citationFormField = config.entry.fields.citationForm as LexConfigMultiText;
+          // don't sort by the first citation form if it is an "-audio" writing system
+          const inputSystem = citationFormField.inputSystems.find((system) => !system.includes('-audio'));
+          if (entry.citationForm && inputSystem && inputSystem in entry.citationForm) {
+            sortableValue = entry.citationForm[inputSystem].value;
           }
+        }
 
-        // regular multi-text field
-        } else {
-          if (field.inputSystems.length > 0 && field.inputSystems[0] in dataNode) {
-            sortableValue = dataNode[field.inputSystems[0]].value;
+        if (!sortableValue) {
+          const lexemeField = config.entry.fields.lexeme as LexConfigMultiText;
+          // don't sort by the first lexeme form if it is an "-audio" writing system
+          const inputSystem = lexemeField.inputSystems.find((system) => !system.includes('-audio'));
+          if (entry.lexeme && inputSystem && inputSystem in entry.lexeme) {
+            sortableValue = entry.lexeme[inputSystem].value;
           }
         }
+      } else if (field.type === 'multitext') {
+        const inputSystems = (field as LexConfigMultiText).inputSystems;
+        if (inputSystems.length > 0 && inputSystems[0] in dataNode) {
+          sortableValue = dataNode[inputSystems[0]].value;
+        }
       } else if (field.type === 'optionlist') {
-        if (config.optionlists && config.optionlists[field.listCode]) {
+        const listCode = (field as LexConfigOptionList).listCode;
+        if (config.optionlists && config.optionlists[listCode]) {
           // something weird here with config.optionlists not being set consistently when this is called - cjh 2017-07
-          sortableValue = this.getOptionListItem(config.optionlists[field.listCode], dataNode.value).value;
+          sortableValue = this.getOptionListItem(config.optionlists[listCode], dataNode.value).value;
         } else {
           sortableValue = dataNode.value;
         }
       } else if (field.type === 'multioptionlist' && dataNode.values.length > 0) {
-        if (field.listCode === 'semantic-domain-ddp4') {
+        const listCode = (field as LexConfigMultiOptionList).listCode;
+        if (listCode === 'semantic-domain-ddp4') {
           if (this.semanticDomains.data[dataNode.values[0]]) {
             sortableValue = this.semanticDomains.data[dataNode.values[0]].value;
           } else {
             sortableValue = dataNode.values[0];
           }
         } else {
-          if (config.optionlists && config.optionlists[field.listCode]) {
-            sortableValue = this.getOptionListItem(config.optionlists[field.listCode], dataNode.values[0]).value;
+          if (config.optionlists && config.optionlists[listCode]) {
+            sortableValue = this.getOptionListItem(config.optionlists[listCode], dataNode.values[0]).value;
           } else {
             sortableValue = dataNode.values[0].value;
           }

src/angular-app/languageforge/lexicon/editor/editor.component.ts

@@ -680,10 +680,11 @@ export class LexiconEditorController implements angular.IController {
 
   getFontFamilyForPrimaryListItemForDisplay(entry: LexEntry) {
     if (!this.getSortableValue(this.lecConfig, entry)) return '';
+
     // FIXME this is not always accurate, given the complexity in get EditorDataService#getSortableValue
-    return this.lecConfig.inputSystems[
-      (this.lecConfig.entry.fields.lexeme as LexConfigMultiText).inputSystems[0]
-    ].cssFontFamily;
+    const lexemeField = this.lecConfig.entry.fields.lexeme as LexConfigMultiText;
+    const inputSystem = lexemeField.inputSystems.find(system => !system.includes('-audio'));
+    return this.lecConfig.inputSystems[inputSystem].cssFontFamily;
   }
 
   getSecondaryListItemForDisplay(entry: LexEntry): string {

test/e2e/utils/project-utils.ts

@@ -74,8 +74,9 @@ export class ProjectTestService {
   async createDefaultProject(testInfo: TestInfo): Promise<TestProject> {
     const project = await this.initTestProject(testInfo.titlePath[0], undefined, users.manager, [users.member]);
     await this.addUserToProject(project, users.observer, "observer");
-    await this.addWritingSystemToProject(project, 'th-fonipa', 'tipa');
+    // add audio first to make sure editor.entries tests fail if the audio is used for the dictionary citation
     await this.addWritingSystemToProject(project, 'th-Zxxx-x-audio', 'taud');
+    await this.addWritingSystemToProject(project, 'th-fonipa', 'tipa');
     await this.addPictureFileToProject(project, entries.entry1.senses[0].pictures[0].fileName);
     await this.addAudioVisualFileToProject(project, entries.entry1.lexeme['th-Zxxx-x-audio'].value);
     const projectEntries = await Promise.all([