Merge pull request #9 from bci-oss/feature/add-language-to-rql-request

Feature/add language to rql request

Author: michelu89

documentation/js-sdk-guide/modules/tooling-guide/images/choose-language.png

@@ -117,6 +117,10 @@ The search input is present allowing you to filter the existing data in the tabl
 
 NOTE:  _The search input will filter the data `*ONLY*` by the existing `*STRING*` properties in the chosen Aspect Model._
 
+Once the search functionality has been enabled, the next step is to choose the default language for remote access. This language selection determines the language used in the statement when accessing the system remotely.
+
+image::choose-language.png[width=100%]
+
 === _Data handling_
 
 After generating a component, you can pass the data from the parent to the child components and also the other way around. There is a prompt present which determines if the data should be handled on the client side or remote via an API call.

documentation/js-sdk-guide/modules/tooling-guide/pages/table-generation.adoc

@@ -32,6 +32,7 @@ import {Observable, Subject, Subscriber} from 'rxjs';
 import {WIZARD_CONFIG_FILE} from '../../utils/file';
 import {TemplateHelper} from '../../utils/template-helper';
 import {Schema} from '../table/schema';
+import * as locale from 'locale-codes';
 
 inquirer.registerPrompt('fuzzypath', require('inquirer-fuzzy-path'));
 inquirer.registerPrompt('suggest', require('inquirer-prompt-suggest'));
@@ -176,7 +177,7 @@ function getTtlPaths(promptSubj: Subject<any>, allAnswers: Schema, subscriber: S
     // listener
     const process = inquirer.prompt(promptSubj as any).ui.process;
     process.subscribe(
-        (singleAnswer: {name: string; answer: any}) => {
+        (singleAnswer: { name: string; answer: any }) => {
             switch (true) {
                 case singleAnswer.name === createOrImport.name: {
                     if (singleAnswer.answer) {
@@ -233,7 +234,8 @@ function getTtlPaths(promptSubj: Subject<any>, allAnswers: Schema, subscriber: S
         err => {
             console.log('Error: ', err);
         },
-        () => {}
+        () => {
+        }
     );
 
     promptSubj.next(createOrImport);
@@ -335,7 +337,7 @@ function loadSourceProcessResult(allAnswers: any, tree: Tree, options: Schema, p
                     .then(aspect => {
                         resolve(
                             !aspect.isCollectionAspect &&
-                                loader.filterElements((entry: DefaultEntity) => entry instanceof DefaultEntity).length >= 1
+                            loader.filterElements((entry: DefaultEntity) => entry instanceof DefaultEntity).length >= 1
                         );
                     })
                     .catch(error => reject(error));
@@ -637,6 +639,36 @@ function getUserConfigQuestions(allAnswers: any, tree: Tree, options: Schema): Q
         default: [],
     };
 
+    const requestChooseLanguageForSearchAction = {
+        type: 'list',
+        name: 'chooseLanguageForSearch',
+        message: 'Which language should be used for the search functionality?',
+        when: (answers: any) =>
+            answers.addCommandBar && new TemplateHelper().isAddCommandBarFunctionSearch(answers.enabledCommandBarFunctions),
+        choices: () => {
+            loadAspect(allAnswers, tree).then(aspect => {
+                const templateHelper = new TemplateHelper();
+                let selectedElement: Aspect | Entity = aspect;
+                if (allAnswers.selectedModelElementUrn && allAnswers.selectedModelElementUrn.length > 0) {
+                    selectedElement = loader.findByUrn(allAnswers.selectedModelElementUrn) as Aspect | Entity;
+                }
+
+                const languageCodes = templateHelper.resolveAllLanguageCodes(selectedElement);
+                const choices = [{name: 'English', value: 'en'}];
+
+
+                languageCodes.forEach(code => {
+                    if (code !== 'en') {
+                        choices.push({name: locale.getByTag(code).name, value: code});
+                    }
+                });
+
+                return choices
+            })
+        },
+        default: 'en',
+    };
+
     const requestCustomCommandBarActions = {
         type: 'suggest',
         name: 'customCommandBarActions',
@@ -695,6 +727,7 @@ function getUserConfigQuestions(allAnswers: any, tree: Tree, options: Schema): Q
         requestCustomRowActions,
         requestAddCommandBar,
         requestEnableCommandBarFunctions,
+        requestChooseLanguageForSearchAction,
         requestCustomCommandBarActions,
         requestEnableRemoteDataHandling,
         requestCustomService,

src/ng-generate/table-prompter/index.ts

@@ -746,7 +746,7 @@ export class TsComponentGenerator {
                         this.customFilterExtension.apply(query);
                     }
 
-                    const queryFilter = query.subNodes.length === 0 ? null : new Query({query: query});
+                    const queryFilter = new Query({query: query});
 
                     const queryOption = new Query();
                     if (this.sort.active) {
@@ -770,6 +770,9 @@ export class TsComponentGenerator {
                     QueryStringifier['encodeRql'] = (value: any) => {
                         return value;
                     };
+                    
+                    const additionalCondition = new Eq('local', '${this.options.chooseLanguageForSearch ? this.options.chooseLanguageForSearch.toUpperCase() : 'EN'}');
+                    queryFilter?.queryNode.subNodes.push(additionalCondition);
 
                     const filterRQLQuery = queryFilter ? QueryStringifier.stringify(queryFilter) : '';
                     const optionsRQLQuery = QueryStringifier.stringify(queryOption).replace('&', ',');
@@ -999,6 +1002,7 @@ export class TsComponentGenerator {
                                AbstractLogicalNode,
                                AbstractNode,
                                And,
+                               Eq,
                                Ge,
                                In,
                                Le,

src/ng-generate/table/generators/ts-component.generator.ts

@@ -54,6 +54,7 @@ export interface Schema extends ComponentSchema, DefaultSchema {
     enableRemoteDataHandling: boolean;
     customRemoteService: boolean;
     enabledCommandBarFunctions: string[];
+    chooseLanguageForSearch: string;
     customCommandBarActions: string[];
     enableVersionSupport: boolean;
     excludedProperties: ExcludedProperty[];

src/ng-generate/table/schema.ts

@@ -13,18 +13,22 @@
 
 import {
     Aspect,
+    Characteristic,
     DefaultAspect,
+    DefaultCharacteristic,
     DefaultCollection,
     DefaultEntity,
     DefaultEntityInstance,
     DefaultEnumeration,
+    DefaultPropertyInstanceDefinition,
     DefaultScalar,
     DefaultSingleEntity,
     Entity,
     Property,
 } from '@esmf/aspect-model-loader';
 import {dasherize, underscore} from '@angular-devkit/core/src/utils/strings';
 import {ExcludedProperty, Schema} from '../ng-generate/table/schema';
+import * as locale from 'locale-codes';
 
 export class TemplateHelper {
     isAspectSelected(options: Schema | any) {
@@ -193,7 +197,7 @@ export class TemplateHelper {
     /**
      * Gets the resolved properties of the complex object.
      */
-    getComplexProperties(complexProp: Property, options: Schema): {complexProp: string; properties: Property[]} {
+    getComplexProperties(complexProp: Property, options: Schema): { complexProp: string; properties: Property[] } {
         const propsToShow = options.complexProps.find(cp => cp.prop === complexProp.name)?.propsToShow;
         const properties = this.getProperties({
             selectedModelElement: complexProp.effectiveDataType as DefaultEntity,
@@ -203,6 +207,48 @@ export class TemplateHelper {
         return {complexProp: complexProp.name, properties: properties};
     }
 
+    resolveAllLanguageCodes(modelElement: Aspect | Entity): Set<string> {
+        const allLanguageCodes: Set<string> = new Set();
+
+        const processElement = (element: Aspect | Entity | Property | Characteristic) => {
+            const { localesPreferredNames, localesDescriptions } = element;
+
+            localesPreferredNames.forEach(code => allLanguageCodes.add(code));
+            localesDescriptions.forEach(code => allLanguageCodes.add(code));
+
+            this.addLocalized(allLanguageCodes);
+
+            if (element instanceof DefaultAspect && element.properties.length >= 1) {
+                element.properties.forEach(processElement);
+            }
+
+            if (element instanceof DefaultPropertyInstanceDefinition) {
+                const characteristic = element.characteristic;
+                if (characteristic) {
+                    processElement(characteristic);
+                }
+            }
+
+            if (element instanceof DefaultCharacteristic && element.dataType && element.dataType.isComplex) {
+                processElement(<Entity>element.dataType);
+            }
+
+            if (element instanceof DefaultEntity && element.isComplex && element.properties) {
+                element.properties.forEach(processElement);
+            }
+        };
+
+        processElement(modelElement);
+
+        return allLanguageCodes;
+    }
+
+    addLocalized(languages: Set<string>): string[] {
+        return Array.from(languages)
+            .map(languageCode => locale.getByTag(languageCode).tag)
+            .filter(e => !!e);
+    }
+
     resolveType(modelElement: Aspect | Entity): Aspect | Entity {
         if (modelElement instanceof DefaultAspect && modelElement.isCollectionAspect) {
             const collectionProperty = modelElement.properties.find(prop => prop.characteristic instanceof DefaultCollection);