Merged ux-plus-2023_02_x into ux-plus-2023_02_x-back-porting-UXP-103

Author: atarix83

package.json

@@ -17,8 +17,8 @@
     "build:stats": "ng build --stats-json",
     "build:ci": "ng config cli.cache.environment ci && yarn run build:ssr",
     "build:prod": "cross-env NODE_ENV=production yarn run build:ssr",
-    "build:ssr": "npm run ng-high-memory -- build --configuration production && ng run dspace-angular:server:production",
-    "ng-high-memory": "node --max_old_space_size=8192 node_modules/@angular/cli/bin/ng",
+    "build:ssr": "npm run ng-high-memory -- build --configuration production && npm run ng-high-memory -- run dspace-angular:server:production",
+    "ng-high-memory": "node --max-old-space-size=8192 node_modules/@angular/cli/bin/ng",
     "test": "npm run ng-high-memory -- test --source-map=true --watch=false --configuration test",
     "test:watch": "nodemon --exec \"npm run ng-high-memory -- test --source-map=true --watch=true --configuration test\"",
     "test:headless": "npm run ng-high-memory -- test --source-map=true --watch=false --configuration test --browsers=ChromeHeadless --code-coverage",

src/app/core/json-patch/builder/json-patch-operations-builder.ts

@@ -110,27 +110,25 @@ export class JsonPatchOperationsBuilder {
           operationValue = [];
           value.forEach((entry) => {
             if ((typeof entry === 'object')) {
-              if (securityLevel != null) {
+              if (isNotEmpty(securityLevel)) {
                 operationValue.push(this.prepareObjectValue(entry, securityLevel));
               } else {
                 operationValue.push(this.prepareObjectValue(entry));
               }
-
             } else {
               operationValue.push(new FormFieldMetadataValueObject(entry, null, securityLevel));
             }
           });
         } else if (typeof value === 'object') {
-          if (securityLevel != null) {
+          if (isNotEmpty(securityLevel)) {
             operationValue = this.prepareObjectValue(value, securityLevel);
           } else {
             operationValue = this.prepareObjectValue(value);
           }
-
         } else {
           // add the possibility to add security level when value is string
           // in this case security level is set on metadata value
-          if (securityLevel != null) {
+          if (isNotEmpty(securityLevel)) {
             operationValue = new FormFieldMetadataValueObject(value, null, securityLevel);
           } else  {
             operationValue = new FormFieldMetadataValueObject(value, null);
@@ -143,21 +141,21 @@ export class JsonPatchOperationsBuilder {
   }
 
   protected prepareObjectValue(value: any, securityLevel = null) {
-     let operationValue = Object.create({});
+    let operationValue = Object.create({});
     if (isEmpty(value) || value instanceof FormFieldMetadataValueObject) {
-      if (securityLevel != null) {
-      operationValue = {...value, securityLevel: securityLevel};
-      } else  {
+      if (isNotEmpty(securityLevel)) {
+        operationValue = { ...value, securityLevel: securityLevel };
+      } else {
         operationValue = value;
       }
     } else if (value instanceof Date) {
       if (securityLevel != null) {
-      operationValue = new FormFieldMetadataValueObject(dateToISOFormat(value), null, securityLevel);
+        operationValue = new FormFieldMetadataValueObject(dateToISOFormat(value), null, securityLevel);
       } else {
         operationValue = new FormFieldMetadataValueObject(dateToISOFormat(value));
       }
     } else if (value instanceof VocabularyEntry) {
-      operationValue = this.prepareAuthorityValue(value);
+      operationValue = new FormFieldMetadataValueObject(value.value, null, value.securityLevel, value.authority);
     } else if (value instanceof FormFieldLanguageValueObject) {
       operationValue = new FormFieldMetadataValueObject(value.value, value.language, securityLevel);
     } else if (value.hasOwnProperty('authority')) {
@@ -170,11 +168,10 @@ export class JsonPatchOperationsBuilder {
       Object.keys(value)
         .forEach((key) => {
           if (typeof value[key] === 'object') {
-            if (securityLevel != null) {
-            operationValue[key] = this.prepareObjectValue(value[key], securityLevel);
+            if (isNotEmpty(securityLevel)) {
+              operationValue[key] = this.prepareObjectValue(value[key], securityLevel);
             } else {
- operationValue[key] = this.prepareObjectValue(value[key]);
-
+              operationValue[key] = this.prepareObjectValue(value[key]);
             }
           } else {
             operationValue[key] = value[key];
@@ -184,14 +181,4 @@ export class JsonPatchOperationsBuilder {
     return operationValue;
   }
 
-  protected prepareAuthorityValue(value: any): FormFieldMetadataValueObject {
-    let operationValue: FormFieldMetadataValueObject;
-    if (isNotEmpty(value.authority)) {
-      operationValue = new FormFieldMetadataValueObject(value.value, value.language, value.securityLevel, value.authority);
-    } else {
-      operationValue = new FormFieldMetadataValueObject(value.value, value.language, value.securityLevel,);
-    }
-    return operationValue;
-  }
-
 }

src/app/core/shared/client-math.service.ts

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { environment } from 'src/environments/environment';
+import { MathJaxConfig, MathService } from './math.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ClientMathService extends MathService {
+
+  protected isReady$: Subject<boolean>;
+
+  protected mathJaxOptions = {
+    tex: {
+      inlineMath: [['$', '$'], ['\\(', '\\)']]
+    },
+    svg: {
+      fontCache: 'global'
+    },
+    startup: {
+      typeset: false
+    }
+  };
+
+  protected mathJax: MathJaxConfig = {
+    source: 'https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js',
+    id: 'MathJaxScript'
+  };
+  protected mathJaxFallback: MathJaxConfig = {
+    source: 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/3.2.2/es5/tex-chtml.min.js',
+    id: 'MathJaxBackupScript'
+  };
+
+  constructor() {
+    super();
+
+    this.isReady$ = new ReplaySubject<boolean>();
+
+    void this.registerMathJaxAsync(this.mathJax)
+      .then(() => this.isReady$.next(true))
+      .catch(_ => {
+        void this.registerMathJaxAsync(this.mathJaxFallback)
+          .then(() => this.isReady$.next(true));
+      });
+  }
+
+  protected async registerMathJaxAsync(config: MathJaxConfig): Promise<any> {
+    if (environment.markdown.mathjax) {
+      return new Promise<void>((resolve, reject) => {
+
+        const optionsScript: HTMLScriptElement = document.createElement('script');
+        optionsScript.type = 'text/javascript';
+        optionsScript.text = `MathJax = ${JSON.stringify(this.mathJaxOptions)};`;
+        document.head.appendChild(optionsScript);
+
+        const script: HTMLScriptElement = document.createElement('script');
+        script.id = config.id;
+        script.type = 'text/javascript';
+        script.src = config.source;
+        script.crossOrigin = 'anonymous';
+        script.async = true;
+        script.onload = () => resolve();
+        script.onerror = error => reject(error);
+        document.head.appendChild(script);
+      });
+    }
+    return Promise.resolve();
+  }
+
+  ready(): Observable<boolean> {
+    return this.isReady$;
+  }
+
+  render(element: HTMLElement) {
+    if (environment.markdown.mathjax) {
+      (window as any).MathJax.typesetPromise([element]);
+    }
+  }
+}

src/app/core/shared/math.service.spec.ts

@@ -0,0 +1,47 @@
+import { TestBed } from '@angular/core/testing';
+import { Observable, of } from 'rxjs';
+import { MathService, MathJaxConfig } from './math.service';
+
+export class MockMathService extends MathService {
+  protected mathJaxOptions: any = {};
+  protected mathJax: MathJaxConfig = { source: '', id: '' };
+  protected mathJaxFallback: MathJaxConfig = { source: '', id: '' };
+
+  protected registerMathJaxAsync(config: MathJaxConfig): Promise<any> {
+    return Promise.resolve();
+  }
+
+  ready(): Observable<boolean> {
+    return of(true);
+  }
+
+  render(element: HTMLElement): void {
+    return;
+  }
+}
+
+describe('MathService', () => {
+  let service: MockMathService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = new MockMathService();
+    spyOn(service, 'render');
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should be ready', (done) => {
+    service.ready().subscribe(isReady => {
+      expect(isReady).toBe(true);
+      done();
+    });
+  });
+
+  it('should render', () => {
+    service.render(document.createElement('div'));
+    expect(service.render).toHaveBeenCalled();
+  });
+});

src/app/core/shared/math.service.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+
+export interface MathJaxConfig {
+  source: string;
+  id: string;
+}
+
+export abstract class MathService {
+  protected abstract mathJaxOptions: any;
+  protected abstract mathJax: MathJaxConfig;
+  protected abstract mathJaxFallback: MathJaxConfig;
+
+  protected abstract registerMathJaxAsync(config: MathJaxConfig): Promise<any>;
+  abstract ready(): Observable<boolean>;
+  abstract render(element: HTMLElement): void;
+}

src/app/core/shared/server-math.service.ts

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { MathJaxConfig, MathService } from './math.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ServerMathService extends MathService {
+
+  protected signal: Subject<boolean>;
+
+  protected mathJaxOptions = {};
+
+  protected mathJax: MathJaxConfig = {
+    source: '',
+    id: ''
+  };
+  protected mathJaxFallback: MathJaxConfig = {
+    source: '',
+    id: ''
+  };
+
+  constructor() {
+    super();
+
+    this.signal = new ReplaySubject<boolean>();
+    this.signal.next(true);
+  }
+
+  protected async registerMathJaxAsync(config: MathJaxConfig): Promise<any> {
+    return Promise.resolve();
+  }
+
+  ready(): Observable<boolean> {
+    return this.signal;
+  }
+
+  render(element: HTMLElement) {
+    return;
+  }
+}

src/app/core/submission/vocabularies/models/vocabulary-entry-detail.model.ts

@@ -1,9 +1,12 @@
+import { Observable } from 'rxjs';
 import { autoserialize, deserialize, inheritSerialization } from 'cerialize';
 
 import { HALLink } from '../../../shared/hal-link.model';
 import { VOCABULARY_ENTRY_DETAIL } from './vocabularies.resource-type';
-import { typedObject } from '../../../cache/builders/build-decorators';
+import { link, typedObject } from '../../../cache/builders/build-decorators';
 import { VocabularyEntry } from './vocabulary-entry.model';
+import { RemoteData } from '../../../data/remote-data';
+import { PaginatedList } from '../../../data/paginated-list.model';
 
 /**
  * Model class for a VocabularyEntryDetail
@@ -33,7 +36,21 @@ export class VocabularyEntryDetail extends VocabularyEntry {
     self: HALLink;
     vocabulary: HALLink;
     parent: HALLink;
-    children
+    children: HALLink;
   };
 
+  /**
+   * The submitter for this SubmissionObject
+   * Will be undefined unless the submitter {@link HALLink} has been resolved.
+   */
+  @link(VOCABULARY_ENTRY_DETAIL)
+  parent?: Observable<RemoteData<VocabularyEntryDetail>>;
+
+  /**
+   * The submitter for this SubmissionObject
+   * Will be undefined unless the submitter {@link HALLink} has been resolved.
+   */
+  @link(VOCABULARY_ENTRY_DETAIL, true)
+  children?: Observable<RemoteData<PaginatedList<VocabularyEntryDetail>>>;
+
 }

src/app/core/submission/vocabularies/models/vocabulary-entry.model.ts

@@ -50,8 +50,6 @@ export class VocabularyEntry extends ListableObject {
   @autoserialize
   securityLevel: number;
 
-
-
   /**
    * A string representing the kind of vocabulary entry
    */

src/app/core/submission/vocabularies/vocabulary-entry-details.data.service.ts

@@ -54,13 +54,29 @@ export class VocabularyEntryDetailsDataService extends IdentifiableDataService<V
    *                                    requested after the response becomes stale
    * @param linksToFollow               List of {@link FollowLinkConfig} that indicate which
    *                                    {@link HALLink}s should be automatically resolved
-   * @return {Observable<RemoteData<PaginatedList<T>>>}
+   * @return {Observable<RemoteData<PaginatedList<VocabularyEntryDetail>>>}
    *    Return an observable that emits object list
    */
   public findAll(options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig<VocabularyEntryDetail>[]): Observable<RemoteData<PaginatedList<VocabularyEntryDetail>>> {
     return this.findAllData.findAll(options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
   }
 
+  /**
+   * Returns an observable of {@link RemoteData} of an object, based on its ID, with a list of
+   * {@link FollowLinkConfig}, to automatically resolve {@link HALLink}s of the object
+   * @param id                          ID of object we want to retrieve
+   * @param useCachedVersionIfAvailable If this is true, the request will only be sent if there's
+   *                                    no valid cached version. Defaults to true
+   * @param reRequestOnStale            Whether or not the request should automatically be re-
+   *                                    requested after the response becomes stale
+   * @param linksToFollow               List of {@link FollowLinkConfig} that indicate which
+   *                                    {@link HALLink}s should be automatically resolved
+   */
+  findById(id: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, ...linksToFollow: FollowLinkConfig<VocabularyEntryDetail>[]): Observable<RemoteData<VocabularyEntryDetail>> {
+    const href$ = this.getIDHrefObs(id, ...linksToFollow);
+    return this.findByHref(href$, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+  }
+
   /**
    * Make a new FindListRequest with given search method
    *